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

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

_ZN8usbguard23AllowedMatchesConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   32|  29.7k|    : RuleConditionBase("allowed-matches", device_spec, negated)
   33|  29.7k|  {
   34|  29.7k|    _device_match_rule = parseRuleFromString(std::string("allow ") + device_spec);
   35|  29.7k|    _interface_ptr = nullptr;
   36|  29.7k|  }
_ZN8usbguard23AllowedMatchesConditionC2ERKS0_:
   39|  39.0k|    : RuleConditionBase(rhs)
   40|  39.0k|  {
   41|  39.0k|    _device_match_rule = rhs._device_match_rule;
   42|  39.0k|    _interface_ptr = rhs._interface_ptr;
   43|  39.0k|  }
_ZNK8usbguard23AllowedMatchesCondition5cloneEv:
   63|  39.0k|  {
   64|  39.0k|    return new AllowedMatchesCondition(*this);
   65|  39.0k|  }

_ZN8usbguard19FixedStateConditionC2Ebb:
   30|   601k|    : RuleConditionBase(state ? "true" : "false", negated),
  ------------------
  |  Branch (30:25): [True: 601k, False: 270]
  ------------------
   31|   601k|      _state(state)
   32|   601k|  {
   33|   601k|  }
_ZN8usbguard19FixedStateConditionC2ERKS0_:
   36|  1.48M|    : RuleConditionBase(rhs),
   37|  1.48M|      _state(rhs._state)
   38|  1.48M|  {
   39|  1.48M|  }
_ZNK8usbguard19FixedStateCondition5cloneEv:
   48|  1.48M|  {
   49|  1.48M|    return new FixedStateCondition(*this);
   50|  1.48M|  }

_ZN8usbguard18LocaltimeConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   36|  2.63k|    : RuleConditionBase("localtime", time_range, negated)
   37|  2.63k|  {
   38|  2.63k|    std::string time_begin;
   39|  2.63k|    std::string time_end;
   40|  2.63k|    const size_t dash_pos = time_range.find('-');
   41|       |
   42|  2.63k|    if (dash_pos == std::string::npos) {
  ------------------
  |  Branch (42:9): [True: 463, False: 2.16k]
  ------------------
   43|    463|      time_begin = time_range;
   44|    463|    }
   45|  2.16k|    else {
   46|  2.16k|      time_begin = time_range.substr(0, dash_pos);
   47|  2.16k|      time_end = time_range.substr(dash_pos + 1);
   48|  2.16k|    }
   49|       |
   50|  2.63k|    _daytime_begin = stringToDaytime(time_begin);
   51|       |
   52|  2.63k|    if (!time_end.empty()) {
  ------------------
  |  Branch (52:9): [True: 1.10k, False: 1.52k]
  ------------------
   53|  1.10k|      _daytime_end = stringToDaytime(time_end);
   54|  1.10k|    }
   55|  1.52k|    else {
   56|  1.52k|      _daytime_end = _daytime_begin;
   57|  1.52k|    }
   58|       |
   59|  2.63k|    if (_daytime_begin > _daytime_end) {
  ------------------
  |  Branch (59:9): [True: 32, False: 2.59k]
  ------------------
   60|     32|      throw Exception("LocaltimeCondition", "Invalid time range (begin > end)", time_range);
   61|     32|    }
   62|  2.63k|  }
_ZN8usbguard18LocaltimeConditionC2ERKS0_:
   65|  3.80k|    : RuleConditionBase(rhs)
   66|  3.80k|  {
   67|  3.80k|    _daytime_begin = rhs._daytime_begin;
   68|  3.80k|    _daytime_end = rhs._daytime_end;
   69|  3.80k|  }
_ZNK8usbguard18LocaltimeCondition5cloneEv:
   84|  3.80k|  {
   85|  3.80k|    return new LocaltimeCondition(*this);
   86|  3.80k|  }
_ZN8usbguard18LocaltimeCondition15stringToDaytimeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  114|  3.73k|  {
  115|  3.73k|    USBGUARD_LOG(Trace) << "string=" << string;
  ------------------
  |  |  310|  3.73k|  if (USBGUARD_LOGGER.isEnabled(usbguard::LogStream::Level::level)) \
  |  |  ------------------
  |  |  |  |  305|  3.73k|#define USBGUARD_LOGGER usbguard::G_logger
  |  |  ------------------
  |  |  |  Branch (310:7): [True: 0, False: 3.73k]
  |  |  ------------------
  |  |  311|  3.73k|    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|       |  #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|  3.73k|    struct ::tm tm = { };
  117|       |
  118|  3.73k|    if (::strptime(string.c_str(), "%H:%M:%s", &tm) == nullptr) {
  ------------------
  |  Branch (118:9): [True: 3.45k, False: 278]
  ------------------
  119|  3.45k|      if (::strptime(string.c_str(), "%H:%M", &tm) == nullptr) {
  ------------------
  |  Branch (119:11): [True: 217, False: 3.23k]
  ------------------
  120|    217|        throw Exception("LocaltimeCondition", "Invalid time or range format", string);
  121|    217|      }
  122|  3.45k|    }
  123|       |
  124|  3.51k|    USBGUARD_LOG(Trace) << "tm=" << tmToString(&tm);
  ------------------
  |  |  310|  3.51k|  if (USBGUARD_LOGGER.isEnabled(usbguard::LogStream::Level::level)) \
  |  |  ------------------
  |  |  |  |  305|  3.51k|#define USBGUARD_LOGGER usbguard::G_logger
  |  |  ------------------
  |  |  |  Branch (310:7): [True: 0, False: 3.51k]
  |  |  ------------------
  |  |  311|  3.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|       |  #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|  3.51k|    return tm.tm_sec + 60*tm.tm_min + 60*60*tm.tm_hour;
  126|  3.73k|  }

_ZN8usbguard20RandomStateConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   32|  1.87k|    : RuleConditionBase("random", true_probability, negated),
   33|  1.87k|      _rng_gen(_rng_device()),
   34|  1.87k|      _true_probability(true_probability.empty() ? 0.5 : std::stod(true_probability)),
  ------------------
  |  Branch (34:25): [True: 1.03k, False: 839]
  ------------------
   35|  1.87k|      _rng_dist(_true_probability)
   36|  1.87k|  {
   37|  1.87k|  }
_ZN8usbguard20RandomStateConditionC2ERKS0_:
   40|  3.10k|    : RuleConditionBase(rhs),
   41|  3.10k|      _rng_gen(_rng_device()),
   42|  3.10k|      _true_probability(rhs._true_probability),
   43|  3.10k|      _rng_dist(_true_probability)
   44|  3.10k|  {
   45|  3.10k|  }
_ZNK8usbguard20RandomStateCondition5cloneEv:
   54|  3.10k|  {
   55|  3.10k|    return new RandomStateCondition(*this);
   56|  3.10k|  }

_ZN8usbguard20RuleAppliedConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   37|  1.33k|    : RuleConditionBase("rule-applied", elapsed_time, negated)
   38|  1.33k|  {
   39|  1.33k|    _elapsed_time = std::chrono::steady_clock::duration(stringToSeconds(elapsed_time));
   40|  1.33k|  }
_ZN8usbguard20RuleAppliedConditionC2ERKS0_:
   43|  2.63k|    : RuleConditionBase(rhs),
   44|  2.63k|      _elapsed_time(rhs._elapsed_time)
   45|  2.63k|  {
   46|  2.63k|  }
_ZNK8usbguard20RuleAppliedCondition5cloneEv:
   68|  2.63k|  {
   69|  2.63k|    return new RuleAppliedCondition(*this);
   70|  2.63k|  }
_ZN8usbguard20RuleAppliedCondition15stringToSecondsERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   73|  1.33k|  {
   74|  1.33k|    struct ::tm tm = { };
   75|       |
   76|  1.33k|    if (string.empty() || string == "") {
  ------------------
  |  Branch (76:9): [True: 344, False: 990]
  |  Branch (76:27): [True: 0, False: 990]
  ------------------
   77|    344|      return 0;
   78|    344|    }
   79|       |
   80|    990|    if (::strptime(string.c_str(), "%H:%M:%s", &tm) == nullptr) {
  ------------------
  |  Branch (80:9): [True: 796, False: 194]
  ------------------
   81|    796|      if (::strptime(string.c_str(), "%H:%M", &tm) == nullptr) {
  ------------------
  |  Branch (81:11): [True: 477, False: 319]
  ------------------
   82|    477|        if (::strptime(string.c_str(), "%s", &tm) == nullptr) {
  ------------------
  |  Branch (82:13): [True: 7, False: 470]
  ------------------
   83|      7|          throw std::runtime_error("Invalid time string. Expecing either HH:MM or HH:MM:SS format.");
   84|      7|        }
   85|    477|      }
   86|    796|    }
   87|       |
   88|    983|    return tm.tm_sec + 60*tm.tm_min + 60*60*tm.tm_hour;
   89|    990|  }

_ZN8usbguard22RuleEvaluatedConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   38|  2.03k|    : RuleConditionBase("rule-applied", elapsed_time, negated)
   39|  2.03k|  {
   40|  2.03k|    _elapsed_time = std::chrono::steady_clock::duration(stringToSeconds(elapsed_time));
   41|  2.03k|  }
_ZN8usbguard22RuleEvaluatedConditionC2ERKS0_:
   44|  3.17k|    : RuleConditionBase(rhs),
   45|  3.17k|      _elapsed_time(rhs._elapsed_time)
   46|  3.17k|  {
   47|  3.17k|  }
_ZNK8usbguard22RuleEvaluatedCondition5cloneEv:
   69|  3.17k|  {
   70|  3.17k|    return new RuleEvaluatedCondition(*this);
   71|  3.17k|  }
_ZN8usbguard22RuleEvaluatedCondition15stringToSecondsERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   74|  2.03k|  {
   75|  2.03k|    struct ::tm tm = { };
   76|       |
   77|  2.03k|    if (string.empty() || string == "") {
  ------------------
  |  Branch (77:9): [True: 507, False: 1.53k]
  |  Branch (77:27): [True: 0, False: 1.53k]
  ------------------
   78|    507|      return 0;
   79|    507|    }
   80|       |
   81|  1.53k|    if (::strptime(string.c_str(), "%H:%M:%s", &tm) == nullptr) {
  ------------------
  |  Branch (81:9): [True: 1.33k, False: 194]
  ------------------
   82|  1.33k|      if (::strptime(string.c_str(), "%H:%M", &tm) == nullptr) {
  ------------------
  |  Branch (82:11): [True: 1.13k, False: 201]
  ------------------
   83|  1.13k|        if (::strptime(string.c_str(), "%s", &tm) == nullptr) {
  ------------------
  |  Branch (83:13): [True: 9, False: 1.12k]
  ------------------
   84|      9|          throw std::runtime_error("Invalid time string. Expecing either HH:MM, HH:MM:SS or SS format.");
   85|      9|        }
   86|  1.13k|      }
   87|  1.33k|    }
   88|       |
   89|  1.52k|    return tm.tm_sec + 60*tm.tm_min + 60*60*tm.tm_hour;
   90|  1.53k|  }

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

_ZN8usbguard11RulePrivateC2Ev:
   33|   107k|    : _device_id("id"),
   34|   107k|      _serial("serial"),
   35|   107k|      _with_connect_type("with-connect-type"),
   36|   107k|      _name("name"),
   37|   107k|      _hash("hash"),
   38|   107k|      _parent_hash("parent-hash"),
   39|   107k|      _via_port("via-port"),
   40|   107k|      _with_interface("with-interface"),
   41|   107k|      _conditions("if"),
   42|   107k|      _label("label")
   43|   107k|  {
   44|   107k|    _rule_id = Rule::DefaultID;
   45|   107k|    _target = Rule::Target::Invalid;
   46|   107k|    _conditions_state = 0;
   47|   107k|  }
_ZN8usbguard11RulePrivateC2ERKS0_:
   50|  67.8k|    : _device_id("id"),
   51|  67.8k|      _serial("serial"),
   52|  67.8k|      _with_connect_type("with-connect-type"),
   53|  67.8k|      _name("name"),
   54|  67.8k|      _hash("hash"),
   55|  67.8k|      _parent_hash("parent-hash"),
   56|  67.8k|      _via_port("via-port"),
   57|  67.8k|      _with_interface("with-interface"),
   58|  67.8k|      _conditions("if"),
   59|  67.8k|      _label("label")
   60|  67.8k|  {
   61|  67.8k|    *this = rhs;
   62|  67.8k|  }
_ZN8usbguard11RulePrivate9setTargetENS_4Rule6TargetE:
  227|  38.3k|  {
  228|  38.3k|    _target = target;
  229|  38.3k|  }
_ZNK8usbguard11RulePrivate9getTargetEv:
  232|  10.3k|  {
  233|  10.3k|    return _target;
  234|  10.3k|  }
_ZN8usbguard11RulePrivate11setDeviceIDERKNS_11USBDeviceIDE:
  237|  1.75k|  {
  238|  1.75k|    _device_id.set(device_id);
  239|  1.75k|  }
_ZN8usbguard11RulePrivate17attributeDeviceIDEv:
  252|   960k|  {
  253|   960k|    return _device_id;
  254|   960k|  }
_ZN8usbguard11RulePrivate15attributeSerialEv:
  272|  8.89k|  {
  273|  8.89k|    return _serial;
  274|  8.89k|  }
_ZN8usbguard11RulePrivate14attributeLabelEv:
  292|  7.46k|  {
  293|  7.46k|    return _label;
  294|  7.46k|  }
_ZN8usbguard11RulePrivate24attributeWithConnectTypeEv:
  312|  9.11k|  {
  313|  9.11k|    return _with_connect_type;
  314|  9.11k|  }
_ZN8usbguard11RulePrivate13attributeNameEv:
  332|   316k|  {
  333|   316k|    return _name;
  334|   316k|  }
_ZN8usbguard11RulePrivate13attributeHashEv:
  352|  12.7k|  {
  353|  12.7k|    return _hash;
  354|  12.7k|  }
_ZN8usbguard11RulePrivate19attributeParentHashEv:
  372|  11.5k|  {
  373|  11.5k|    return _parent_hash;
  374|  11.5k|  }
_ZN8usbguard11RulePrivate16attributeViaPortEv:
  392|  10.2k|  {
  393|  10.2k|    return _via_port;
  394|  10.2k|  }
_ZN8usbguard11RulePrivate22attributeWithInterfaceEv:
  402|   171k|  {
  403|   171k|    return _with_interface;
  404|   171k|  }
_ZN8usbguard11RulePrivate19attributeConditionsEv:
  412|   647k|  {
  413|   647k|    return _conditions;
  414|   647k|  }

_ZN8usbguard11RulePrivateD2Ev:
   55|   175k|    ~RulePrivate() = default;
_ZN8usbguard11RulePrivate8MetaDataC2Ev:
   38|   175k|        : tp_created(std::chrono::steady_clock::now())
   39|   175k|      {
   40|   175k|      }
_ZN8usbguard11RulePrivateaSERKS0_:
   54|  67.8k|    RulePrivate& operator=(const RulePrivate& rhs) = default;

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

_ZN8usbguard9ExceptionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_S9_:
   45|    249|      : _context(context),
   46|    249|        _object(object),
   47|    249|        _reason(reason_val)
   48|    249|    {
   49|    249|    }
_ZNK8usbguard9Exception4whatEv:
  105|    249|    {
  106|    249|      return "usbguard::Exception";
  107|    249|    }

_ZN8usbguard7LogSinkC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  100|      2|    : _name(name)
  101|      2|  {
  102|      2|  }
_ZNK8usbguard7LogSink4nameEv:
  109|      2|  {
  110|      2|    return _name;
  111|      2|  }
_ZN8usbguard6LoggerC2Ev:
  281|      2|    : _enabled(true),
  282|      2|      _level(LogStream::Level::Warning)
  283|      2|  {
  284|      2|    const char* const envval = getenv("USBGUARD_DEBUG");
  285|       |
  286|       |    /*
  287|       |     * If USBGUARD_DEBUG=1 is set in the current environment,
  288|       |     * set the debugging level to the highest level.
  289|       |     */
  290|      2|    if (envval != nullptr && strcmp(envval, "1") == 0) {
  ------------------
  |  Branch (290:9): [True: 0, False: 2]
  |  Branch (290:30): [True: 0, False: 0]
  ------------------
  291|      0|      _level = LogStream::Level::Trace;
  292|      0|    }
  293|       |
  294|      2|    setOutputConsole(true);
  295|      2|  }
_ZNK8usbguard6Logger4lockEv:
  302|  7.25k|  {
  303|  7.25k|    return std::unique_lock<std::mutex>(_mutex);
  304|  7.25k|  }
_ZNK8usbguard6Logger9isEnabledENS_9LogStream5LevelE:
  314|  7.24k|  {
  315|  7.24k|    auto L = lock();
  316|  7.24k|    return (_enabled && _level >= level);
  ------------------
  |  Branch (316:13): [True: 7.24k, False: 0]
  |  Branch (316:25): [True: 0, False: 7.24k]
  ------------------
  317|  7.24k|  }
_ZN8usbguard6Logger16setOutputConsoleEb:
  320|      2|  {
  321|      2|    auto L = lock();
  322|       |
  323|      2|    if (state == true) {
  ------------------
  |  Branch (323:9): [True: 2, False: 0]
  ------------------
  324|      2|      std::unique_ptr<LogSink> sink(new ConsoleSink);
  325|      2|      addOutputSink_nolock(sink);
  326|      2|    }
  327|      0|    else {
  328|      0|      delOutputSink_nolock("console");
  329|      0|    }
  330|      2|  }
_ZN8usbguard6Logger20addOutputSink_nolockERNSt3__110unique_ptrINS_7LogSinkENS1_14default_deleteIS3_EEEE:
  378|      2|  {
  379|      2|    _sinks.emplace(sink->name(), std::move(sink));
  380|      2|  }
_ZN8usbguard11ConsoleSinkC2Ev:
  151|      2|      : OStreamSink("console", std::clog)
  152|      2|    {
  153|      2|    }
_ZN8usbguard11OStreamSinkC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERNS1_13basic_ostreamIcS4_EE:
  120|      2|      : LogSink(name),
  121|      2|        _ostream(stream)
  122|      2|    {
  123|      2|    }

_ZN8usbguard4RuleC2Ev:
   42|   107k|    : d_pointer(usbguard::make_unique<RulePrivate>())
   43|   107k|  {
   44|   107k|  }
_ZN8usbguard4RuleD2Ev:
   46|   107k|  Rule::~Rule() = default;
_ZN8usbguard4RuleaSERKS0_:
   54|  67.8k|  {
   55|  67.8k|    d_pointer.reset(new RulePrivate(*rhs.d_pointer));
   56|  67.8k|    return *this;
   57|  67.8k|  }
_ZN8usbguard4Rule9setTargetENS0_6TargetE:
   70|  38.3k|  {
   71|  38.3k|    d_pointer->setTarget(target);
   72|  38.3k|  }
_ZNK8usbguard4Rule9getTargetEv:
   75|  10.3k|  {
   76|  10.3k|    return d_pointer->getTarget();
   77|  10.3k|  }
_ZN8usbguard4Rule11setDeviceIDERKNS_11USBDeviceIDE:
   80|  1.75k|  {
   81|  1.75k|    d_pointer->setDeviceID(value);
   82|  1.75k|  }
_ZN8usbguard4Rule17attributeDeviceIDEv:
   95|   960k|  {
   96|   960k|    return d_pointer->attributeDeviceID();
   97|   960k|  }
_ZN8usbguard4Rule15attributeSerialEv:
  115|  8.89k|  {
  116|  8.89k|    return d_pointer->attributeSerial();
  117|  8.89k|  }
_ZN8usbguard4Rule14attributeLabelEv:
  135|  7.46k|  {
  136|  7.46k|    return d_pointer->attributeLabel();
  137|  7.46k|  }
_ZN8usbguard4Rule24attributeWithConnectTypeEv:
  155|  9.11k|  {
  156|  9.11k|    return d_pointer->attributeWithConnectType();
  157|  9.11k|  }
_ZN8usbguard4Rule13attributeNameEv:
  175|   316k|  {
  176|   316k|    return d_pointer->attributeName();
  177|   316k|  }
_ZN8usbguard4Rule13attributeHashEv:
  195|  12.7k|  {
  196|  12.7k|    return d_pointer->attributeHash();
  197|  12.7k|  }
_ZN8usbguard4Rule19attributeParentHashEv:
  215|  11.5k|  {
  216|  11.5k|    return d_pointer->attributeParentHash();
  217|  11.5k|  }
_ZN8usbguard4Rule16attributeViaPortEv:
  235|  10.2k|  {
  236|  10.2k|    return d_pointer->attributeViaPort();
  237|  10.2k|  }
_ZN8usbguard4Rule22attributeWithInterfaceEv:
  245|   171k|  {
  246|   171k|    return d_pointer->attributeWithInterface();
  247|   171k|  }
_ZN8usbguard4Rule19attributeConditionsEv:
  255|   647k|  {
  256|   647k|    return d_pointer->attributeConditions();
  257|   647k|  }
_ZN8usbguard4Rule16targetFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  333|  38.2k|  {
  334|  44.0k|    for (auto ttable_entry : target_ttable) {
  ------------------
  |  Branch (334:28): [True: 44.0k, False: 0]
  ------------------
  335|  44.0k|      if (ttable_entry.first == target_string) {
  ------------------
  |  Branch (335:11): [True: 38.2k, False: 5.71k]
  ------------------
  336|  38.2k|        return ttable_entry.second;
  337|  38.2k|      }
  338|  44.0k|    }
  339|       |
  340|      0|    throw std::runtime_error("Invalid rule target string");
  341|  38.2k|  }
_ZN8usbguard4Rule21setOperatorFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  387|  15.3k|  {
  388|  57.7k|    for (auto ttable_entry : set_operator_ttable) {
  ------------------
  |  Branch (388:28): [True: 57.7k, False: 0]
  ------------------
  389|  57.7k|      if (ttable_entry.first == set_operator_string) {
  ------------------
  |  Branch (389:11): [True: 15.3k, False: 42.4k]
  ------------------
  390|  15.3k|        return ttable_entry.second;
  391|  15.3k|      }
  392|  57.7k|    }
  393|       |
  394|      0|    throw std::runtime_error("Invalid set operator string");
  395|  15.3k|  }

_ZNK8usbguard4Rule9AttributeINS_11USBDeviceIDEE5emptyEv:
  300|  3.88k|      {
  301|  3.88k|        return count() == 0;
  302|  3.88k|      }
_ZNK8usbguard4Rule9AttributeINS_11USBDeviceIDEE5countEv:
  289|  7.38k|      {
  290|  7.38k|        return _values.size();
  291|  7.38k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE14setSetOperatorENS0_11SetOperatorE:
  249|  1.97k|      {
  250|  1.97k|        _set_operator = op;
  251|  1.97k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE6appendERKS2_:
  279|   956k|      {
  280|   956k|        _values.push_back(value);
  281|   956k|      }
_ZNK8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5emptyEv:
  300|  20.5k|      {
  301|  20.5k|        return count() == 0;
  302|  20.5k|      }
_ZNK8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5countEv:
  289|  20.5k|      {
  290|  20.5k|        return _values.size();
  291|  20.5k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE14setSetOperatorENS0_11SetOperatorE:
  249|  10.1k|      {
  250|  10.1k|        _set_operator = op;
  251|  10.1k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE6appendERKS8_:
  279|   345k|      {
  280|   345k|        _values.push_back(value);
  281|   345k|      }
_ZNK8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE5emptyEv:
  300|  3.38k|      {
  301|  3.38k|        return count() == 0;
  302|  3.38k|      }
_ZNK8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE5countEv:
  289|  3.38k|      {
  290|  3.38k|        return _values.size();
  291|  3.38k|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE14setSetOperatorENS0_11SetOperatorE:
  249|  1.90k|      {
  250|  1.90k|        _set_operator = op;
  251|  1.90k|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE6appendERKS2_:
  279|   165k|      {
  280|   165k|        _values.push_back(value);
  281|   165k|      }
_ZNK8usbguard4Rule9AttributeINS_13RuleConditionEE5emptyEv:
  300|  5.93k|      {
  301|  5.93k|        return count() == 0;
  302|  5.93k|      }
_ZNK8usbguard4Rule9AttributeINS_13RuleConditionEE5countEv:
  289|  5.93k|      {
  290|  5.93k|        return _values.size();
  291|  5.93k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEE14setSetOperatorENS0_11SetOperatorE:
  249|  1.28k|      {
  250|  1.28k|        _set_operator = op;
  251|  1.28k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEE6appendEOS2_:
  269|   638k|      {
  270|   638k|        _values.emplace_back(std::move(value));
  271|   638k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEEaSERKS3_:
  241|  67.8k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEaSERKS9_:
  241|   474k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEEaSERKS3_:
  241|  67.8k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEEaSERKS3_:
  241|  67.8k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEEC2EPKc:
  224|   175k|      {
  225|   175k|        _name = name;
  226|   175k|        _set_operator = SetOperator::Equals;
  227|   175k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPKc:
  224|  1.22M|      {
  225|  1.22M|        _name = name;
  226|  1.22M|        _set_operator = SetOperator::Equals;
  227|  1.22M|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEEC2EPKc:
  224|   175k|      {
  225|   175k|        _name = name;
  226|   175k|        _set_operator = SetOperator::Equals;
  227|   175k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEEC2EPKc:
  224|   175k|      {
  225|   175k|        _name = name;
  226|   175k|        _set_operator = SetOperator::Equals;
  227|   175k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE3setERKS2_:
  384|  1.75k|      {
  385|  1.75k|        if (count() > 1) {
  ------------------
  |  Branch (385:13): [True: 0, False: 1.75k]
  ------------------
  386|      0|          throw std::runtime_error("BUG: Setting single value for a multivalued attribute");
  387|      0|        }
  388|       |
  389|  1.75k|        if (count() == 0) {
  ------------------
  |  Branch (389:13): [True: 1.75k, False: 0]
  ------------------
  390|  1.75k|          append(value);
  391|  1.75k|        }
  392|      0|        else {
  393|      0|          _values[0] = value;
  394|      0|        }
  395|  1.75k|      }

_ZN8usbguard17RuleConditionBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_b:
   34|  37.5k|    : _identifier(identifier),
   35|  37.5k|      _parameter(parameter),
   36|  37.5k|      _negated(negated)
   37|  37.5k|  {
   38|  37.5k|  }
_ZN8usbguard17RuleConditionBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   41|   601k|    : _identifier(identifier),
   42|   601k|      _negated(negated)
   43|   601k|  {
   44|   601k|  }
_ZN8usbguard17RuleConditionBaseC2ERKS0_:
   47|  1.53M|    : _identifier(rhs._identifier),
   48|  1.53M|      _parameter(rhs._parameter),
   49|  1.53M|      _negated(rhs._negated)
   50|  1.53M|  {
   51|  1.53M|  }
_ZN8usbguard17RuleConditionBaseD2Ev:
   54|  2.17M|  {
   55|  2.17M|    fini();
   56|  2.17M|  }
_ZN8usbguard17RuleConditionBase4finiEv:
   64|  2.17M|  {
   65|  2.17M|  }
_ZN8usbguard17RuleConditionBase17getImplementationERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  130|   640k|  {
  131|   640k|    if (condition_string.empty()) {
  ------------------
  |  Branch (131:9): [True: 0, False: 640k]
  ------------------
  132|      0|      throw std::runtime_error("Empty condition");
  133|      0|    }
  134|       |
  135|   640k|    const bool negated = condition_string[0] == '!';
  136|   640k|    const size_t identifier_start = negated ? 1 : 0;
  ------------------
  |  Branch (136:37): [True: 496, False: 639k]
  ------------------
  137|   640k|    const size_t p_pos = condition_string.find_first_of('(');
  138|   640k|    std::string identifier;
  139|   640k|    std::string parameter;
  140|       |
  141|   640k|    if (p_pos == std::string::npos) {
  ------------------
  |  Branch (141:9): [True: 605k, False: 35.0k]
  ------------------
  142|       |      /*
  143|       |       * The rest of the condition_string should be
  144|       |       * a condition identifier -- without a parameter.
  145|       |       */
  146|   605k|      identifier = condition_string.substr(identifier_start);
  147|       |
  148|   605k|      if (identifier.size() < 1) {
  ------------------
  |  Branch (148:11): [True: 0, False: 605k]
  ------------------
  149|      0|        throw std::runtime_error("Invalid condition string. Missing identifier.");
  150|      0|      }
  151|   605k|    }
  152|  35.0k|    else {
  153|  35.0k|      const size_t parameter_size = condition_string.size() - p_pos;
  154|       |
  155|  35.0k|      if (parameter_size < 3 /* two parentheses + at least one character */) {
  ------------------
  |  Branch (155:11): [True: 6, False: 35.0k]
  ------------------
  156|      6|        throw std::runtime_error("Invalid condition string. Invalid parameter.");
  157|      6|      }
  158|       |
  159|  35.0k|      const size_t identifier_size = p_pos - identifier_start;
  160|  35.0k|      identifier = condition_string.substr(identifier_start, identifier_size);
  161|       |
  162|  35.0k|      if (condition_string[condition_string.size() - 1] != ')') {
  ------------------
  |  Branch (162:11): [True: 0, False: 35.0k]
  ------------------
  163|      0|        throw std::runtime_error("Invalid condition string. Malformed parameter.");
  164|      0|      }
  165|       |
  166|  35.0k|      parameter = condition_string.substr(p_pos + 1, parameter_size - 2);
  167|  35.0k|    }
  168|       |
  169|   640k|    return getImplementation(identifier, parameter, negated);
  170|   640k|  }
_ZN8usbguard17RuleConditionBase17getImplementationERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_b:
  174|   640k|  {
  175|   640k|    if (identifier == "allowed-matches") {
  ------------------
  |  Branch (175:9): [True: 29.7k, False: 610k]
  ------------------
  176|  29.7k|      return new AllowedMatchesCondition(parameter, negated);
  177|  29.7k|    }
  178|       |
  179|   610k|    if (identifier == "localtime") {
  ------------------
  |  Branch (179:9): [True: 2.63k, False: 607k]
  ------------------
  180|  2.63k|      return new LocaltimeCondition(parameter, negated);
  181|  2.63k|    }
  182|       |
  183|   607k|    if (identifier == "true") {
  ------------------
  |  Branch (183:9): [True: 601k, False: 6.27k]
  ------------------
  184|   601k|      return new FixedStateCondition(true, negated);
  185|   601k|    }
  186|       |
  187|  6.27k|    if (identifier == "false") {
  ------------------
  |  Branch (187:9): [True: 270, False: 6.00k]
  ------------------
  188|    270|      return new FixedStateCondition(false, negated);
  189|    270|    }
  190|       |
  191|  6.00k|    if (identifier == "random") {
  ------------------
  |  Branch (191:9): [True: 1.87k, False: 4.13k]
  ------------------
  192|  1.87k|      return new RandomStateCondition(parameter, negated);
  193|  1.87k|    }
  194|       |
  195|  4.13k|    if (identifier == "rule-applied") {
  ------------------
  |  Branch (195:9): [True: 1.33k, False: 2.79k]
  ------------------
  196|  1.33k|      return new RuleAppliedCondition(parameter, negated);
  197|  1.33k|    }
  198|       |
  199|  2.79k|    if (identifier == "rule-evaluated") {
  ------------------
  |  Branch (199:9): [True: 2.03k, False: 758]
  ------------------
  200|  2.03k|      return new RuleEvaluatedCondition(parameter, negated);
  201|  2.03k|    }
  202|       |
  203|    758|    throw std::runtime_error("Unknown rule condition");
  204|  2.79k|  }
_ZN8usbguard13RuleConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  211|   640k|    : _condition(RuleConditionBase::getImplementation(condition_string))
  212|   640k|  {
  213|   640k|  }
_ZN8usbguard13RuleConditionC2ERKS0_:
  216|  1.53M|    : _condition(rhs._condition->clone())
  217|  1.53M|  {
  218|  1.53M|  }
_ZN8usbguard13RuleConditionC2EOS0_:
  221|   638k|    : _condition(std::move(rhs._condition))
  222|   638k|  {
  223|   638k|  }

_ZN8usbguard19parseRuleFromStringERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES8_mb:
   46|  38.4k|  {
   47|  38.4k|    try {
   48|  38.4k|      Rule rule;
   49|  38.4k|      tao::pegtl::string_input<> input(rule_spec, file);
   50|       |
   51|  38.4k|      if (!trace) {
  ------------------
  |  Branch (51:11): [True: 38.4k, False: 0]
  ------------------
   52|  38.4k|        tao::pegtl::parse<RuleParser::rule_grammar, RuleParser::rule_parser_actions>(input, rule);
   53|  38.4k|      }
   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.4k|      return rule;
   63|  38.4k|    }
   64|  38.4k|    catch (const tao::pegtl::parse_error& ex) {
   65|  9.18k|      RuleParserError error(rule_spec);
   66|  9.18k|      error.setHint(ex.what());
   67|  9.18k|#if TAO_PEGTL_VERSION_MAJOR >= 3
   68|  9.18k|      error.setOffset(ex.positions().front().column);
   69|       |#else
   70|       |      error.setOffset(ex.positions[0].byte_in_line);
   71|       |#endif
   72|       |
   73|  9.18k|      if (!file.empty() || line != 0) {
  ------------------
  |  Branch (73:11): [True: 8.26k, False: 924]
  |  Branch (73:28): [True: 0, False: 924]
  ------------------
   74|  8.26k|        error.setFileInfo(file, line);
   75|  8.26k|      }
   76|       |
   77|  9.18k|      throw error;
   78|  9.18k|    }
   79|  38.4k|    catch (const std::exception& ex) {
   80|      0|      throw;
   81|      0|    }
   82|  38.4k|  }

_ZN8usbguard15RuleParserErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_S9_mj:
   49|  9.18k|      : _rule_spec(rule_spec),
   50|  9.18k|        _hint(hint),
   51|  9.18k|        _offset(error_offset),
   52|  9.18k|        _file(file),
   53|  9.18k|        _line(error_line)
   54|  9.18k|    {
   55|  9.18k|    }
_ZN8usbguard15RuleParserError7setHintERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   63|  9.18k|    {
   64|  9.18k|      _hint = hint;
   65|  9.18k|    }
_ZN8usbguard15RuleParserError9setOffsetEm:
   73|  9.18k|    {
   74|  9.18k|      _offset = offset;
   75|  9.18k|    }
_ZN8usbguard15RuleParserError11setFileInfoERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmm:
   85|  8.26k|    {
   86|  8.26k|      _file = file;
   87|  8.26k|      _line = error_line;
   88|  8.26k|      _offset = error_offset;
   89|  8.26k|    }
_ZNK8usbguard15RuleParserError4whatEv:
   97|    924|    {
   98|    924|      return "RuleParserError";
   99|    924|    }

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

_ZN8usbguard11USBDeviceIDC2ERKS0_:
  183|  3.27M|    USBDeviceID(const USBDeviceID& rhs) = default;

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

_ZN3tao5pegtl8demangleINS0_3repILj2EJNS0_5ascii6xdigitEEEEEENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEv:
   35|    269|{
   36|    269|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    269|   constexpr auto begin = sv.find( '=' );
   38|    269|   static_assert( begin != std::string_view::npos );
   39|    269|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    269|}
_ZN3tao5pegtl8demangleINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEENSt3__117basic_string_viewIcNSC_11char_traitsIcEEEEv:
   35|    349|{
   36|    349|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    349|   constexpr auto begin = sv.find( '=' );
   38|    349|   static_assert( begin != std::string_view::npos );
   39|    349|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    349|}
_ZN3tao5pegtl8demangleINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEv:
   35|  1.32k|{
   36|  1.32k|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|  1.32k|   constexpr auto begin = sv.find( '=' );
   38|  1.32k|   static_assert( begin != std::string_view::npos );
   39|  1.32k|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|  1.32k|}
_ZN3tao5pegtl8demangleINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEENSt3__117basic_string_viewIcNSC_11char_traitsIcEEEEv:
   35|     62|{
   36|     62|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|     62|   constexpr auto begin = sv.find( '=' );
   38|     62|   static_assert( begin != std::string_view::npos );
   39|     62|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|     62|}
_ZN3tao5pegtl8demangleINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEv:
   35|    255|{
   36|    255|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    255|   constexpr auto begin = sv.find( '=' );
   38|    255|   static_assert( begin != std::string_view::npos );
   39|    255|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    255|}
_ZN3tao5pegtl8demangleINS0_3eofEEENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEv:
   35|  4.55k|{
   36|  4.55k|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|  4.55k|   constexpr auto begin = sv.find( '=' );
   38|  4.55k|   static_assert( begin != std::string_view::npos );
   39|  4.55k|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|  4.55k|}

_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser10id_actionsEJNS4_14rule_attributeINS4_6str_idENS4_15device_id_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  41.8k|      {
   45|  41.8k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  41.8k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser12name_actionsEJNS4_14rule_attributeINS4_8str_nameENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  38.4k|      {
   45|  38.4k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  38.4k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser12hash_actionsEJNS4_14rule_attributeINS4_8str_hashENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  35.1k|      {
   45|  35.1k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  35.1k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser19parent_hash_actionsEJNS4_14rule_attributeINS4_15str_parent_hashENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  31.3k|      {
   45|  31.3k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  31.3k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser14serial_actionsEJNS4_14rule_attributeINS4_10str_serialENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  28.1k|      {
   45|  28.1k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  28.1k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser16via_port_actionsEJNS4_14rule_attributeINS4_12str_via_portENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  25.4k|      {
   45|  25.4k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  25.4k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser22with_interface_actionsEJNS4_14rule_attributeINS4_18str_with_interfaceENS4_15interface_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  22.3k|      {
   45|  22.3k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  22.3k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser25with_connect_type_actionsEJNS4_14rule_attributeINS4_21str_with_connect_typeENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  19.4k|      {
   45|  19.4k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  19.4k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser17condition_actionsEJNS4_14rule_attributeINS4_6str_ifENS4_9conditionEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  16.9k|      {
   45|  16.9k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  16.9k|      }
_ZN3tao5pegtl8internal6actionIN8usbguard10RuleParser13label_actionsEJNS4_14rule_attributeINS4_9str_labelENS4_12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   44|  11.7k|      {
   45|  11.7k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  11.7k|      }

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

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

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

_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.75M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.75M|      else {
   20|  3.75M|         in.bump_in_this_line( count );
   21|  3.75M|      }
   22|  3.75M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  10.3k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  10.3k|      else {
   20|  10.3k|         in.bump_in_this_line( count );
   21|  10.3k|      }
   22|  10.3k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc97ELc108ELc108ELc111ELc119EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  34.5k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  34.5k|      else {
   20|  34.5k|         in.bump_in_this_line( count );
   21|  34.5k|      }
   22|  34.5k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc98ELc108ELc111ELc99ELc107EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.71k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.71k|      else {
   20|  2.71k|         in.bump_in_this_line( count );
   21|  2.71k|      }
   22|  2.71k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc114ELc101ELc106ELc101ELc99ELc116EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|     14|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|     14|      else {
   20|     14|         in.bump_in_this_line( count );
   21|     14|      }
   22|     14|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc109ELc97ELc116ELc99ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|    925|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|    925|      else {
   20|    925|         in.bump_in_this_line( count );
   21|    925|      }
   22|    925|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc100ELc101ELc118ELc105ELc99ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|     48|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|     48|      else {
   20|     48|         in.bump_in_this_line( count );
   21|     48|      }
   22|     48|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.41M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.41M|      else {
   20|  1.41M|         in.bump_in_this_line( count );
   21|  1.41M|      }
   22|  1.41M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.06M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.06M|      else {
   20|  2.06M|         in.bump_in_this_line( count );
   21|  2.06M|      }
   22|  2.06M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.28M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.28M|      else {
   20|  1.28M|         in.bump_in_this_line( count );
   21|  1.28M|      }
   22|  1.28M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc105ELc100EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.88k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.88k|      else {
   20|  3.88k|         in.bump_in_this_line( count );
   21|  3.88k|      }
   22|  3.88k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc97ELc108ELc108ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.05k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.05k|      else {
   20|  2.05k|         in.bump_in_this_line( count );
   21|  2.05k|      }
   22|  2.05k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc111ELc110ELc101ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.51k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.51k|      else {
   20|  2.51k|         in.bump_in_this_line( count );
   21|  2.51k|      }
   22|  2.51k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc110ELc111ELc110ELc101ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.29k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.29k|      else {
   20|  2.29k|         in.bump_in_this_line( count );
   21|  2.29k|      }
   22|  2.29k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc101ELc113ELc117ELc97ELc108ELc115ELc45ELc111ELc114ELc100ELc101ELc114ELc101ELc100EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.66k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.66k|      else {
   20|  2.66k|         in.bump_in_this_line( count );
   21|  2.66k|      }
   22|  2.66k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc101ELc113ELc117ELc97ELc108ELc115EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.32k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.32k|      else {
   20|  3.32k|         in.bump_in_this_line( count );
   21|  3.32k|      }
   22|  3.32k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc109ELc97ELc116ELc99ELc104ELc45ELc97ELc108ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.45k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.45k|      else {
   20|  2.45k|         in.bump_in_this_line( count );
   21|  2.45k|      }
   22|  2.45k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  24.9k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  24.9k|      else {
   20|  24.9k|         in.bump_in_this_line( count );
   21|  24.9k|      }
   22|  24.9k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  21.2k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  21.2k|      else {
   20|  21.2k|         in.bump_in_this_line( count );
   21|  21.2k|      }
   22|  21.2k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc110ELc97ELc109ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.62k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.62k|      else {
   20|  3.62k|         in.bump_in_this_line( count );
   21|  3.62k|      }
   22|  3.62k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   704k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   704k|      else {
   20|   704k|         in.bump_in_this_line( count );
   21|   704k|      }
   22|   704k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.01M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.01M|      else {
   20|  1.01M|         in.bump_in_this_line( count );
   21|  1.01M|      }
   22|  1.01M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   360k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   360k|      else {
   20|   360k|         in.bump_in_this_line( count );
   21|   360k|      }
   22|   360k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_5rangeILNS1_15result_on_foundE1ENS1_9peek_charELc48ELc57EEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   289k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   289k|      else {
   20|   289k|         in.bump_in_this_line( count );
   21|   289k|      }
   22|   289k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   416k|   {
   16|   416k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|   416k|         in.bump( count );
   18|       |      }
   19|       |      else {
   20|       |         in.bump_in_this_line( count );
   21|       |      }
   22|   416k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   104M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   104M|      else {
   20|   104M|         in.bump_in_this_line( count );
   21|   104M|      }
   22|   104M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc104ELc97ELc115ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.13k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.13k|      else {
   20|  4.13k|         in.bump_in_this_line( count );
   21|  4.13k|      }
   22|  4.13k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc112ELc97ELc114ELc101ELc110ELc116ELc45ELc104ELc97ELc115ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.55k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.55k|      else {
   20|  3.55k|         in.bump_in_this_line( count );
   21|  3.55k|      }
   22|  3.55k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc115ELc101ELc114ELc105ELc97ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.90k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.90k|      else {
   20|  2.90k|         in.bump_in_this_line( count );
   21|  2.90k|      }
   22|  2.90k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc118ELc105ELc97ELc45ELc112ELc111ELc114ELc116EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.45k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.45k|      else {
   20|  3.45k|         in.bump_in_this_line( count );
   21|  3.45k|      }
   22|  3.45k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc119ELc105ELc116ELc104ELc45ELc105ELc110ELc116ELc101ELc114ELc102ELc97ELc99ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.38k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.38k|      else {
   20|  3.38k|         in.bump_in_this_line( count );
   21|  3.38k|      }
   22|  3.38k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc119ELc105ELc116ELc104ELc45ELc99ELc111ELc110ELc110ELc101ELc99ELc116ELc45ELc116ELc121ELc112ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.84k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.84k|      else {
   20|  2.84k|         in.bump_in_this_line( count );
   21|  2.84k|      }
   22|  2.84k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc105ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  5.93k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  5.93k|      else {
   20|  5.93k|         in.bump_in_this_line( count );
   21|  5.93k|      }
   22|  5.93k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|    505|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|    505|      else {
   20|    505|         in.bump_in_this_line( count );
   21|    505|      }
   22|    505|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|   640k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   640k|      else {
   20|   640k|         in.bump_in_this_line( count );
   21|   640k|      }
   22|   640k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|  28.8M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  28.8M|      else {
   20|  28.8M|         in.bump_in_this_line( count );
   21|  28.8M|      }
   22|  28.8M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  35.4k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  35.4k|      else {
   20|  35.4k|         in.bump_in_this_line( count );
   21|  35.4k|      }
   22|  35.4k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  35.6k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   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.24k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.24k|      else {
   20|  4.24k|         in.bump_in_this_line( count );
   21|  4.24k|      }
   22|  4.24k|   }

_ZN3tao5pegtl8internal3eof5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEEEEEEbRT_:
   22|   557k|      {
   23|   557k|         return in.empty();
   24|   557k|      }

_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNSI_4RuleEEEEbRT3_DpOT4_:
   37|  72.1k|      {
   38|  72.1k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 10.3k, False: 61.7k]
  ------------------
   39|  10.3k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  10.3k|            return true;
   41|  10.3k|         }
   42|  61.7k|         return Default;
   43|  72.1k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|   312k|      {
   38|   312k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 311k, False: 951]
  ------------------
   39|   311k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   311k|            return true;
   41|   311k|         }
   42|    951|         return Default;
   43|   312k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  16.7M|      {
   38|  16.7M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 264k, False: 16.4M]
  ------------------
   39|   264k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   264k|            return true;
   41|   264k|         }
   42|  16.4M|         return Default;
   43|  16.7M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|   264k|      {
   38|   264k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 117k, False: 146k]
  ------------------
   39|   117k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   117k|            return true;
   41|   117k|         }
   42|   146k|         return Default;
   43|   264k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|   146k|      {
   38|   146k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 39.4k, False: 106k]
  ------------------
   39|  39.4k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  39.4k|            return true;
   41|  39.4k|         }
   42|   106k|         return Default;
   43|   146k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  8.74k|      {
   38|  8.74k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 7.50k, False: 1.23k]
  ------------------
   39|  7.50k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  7.50k|            return true;
   41|  7.50k|         }
   42|  1.23k|         return Default;
   43|  8.74k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  9.86M|      {
   38|  9.86M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 143k, False: 9.71M]
  ------------------
   39|   143k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   143k|            return true;
   41|   143k|         }
   42|  9.71M|         return Default;
   43|  9.86M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|   143k|      {
   38|   143k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 48.1k, False: 95.4k]
  ------------------
   39|  48.1k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  48.1k|            return true;
   41|  48.1k|         }
   42|  95.4k|         return Default;
   43|   143k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|  95.4k|      {
   38|  95.4k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 48.0k, False: 47.4k]
  ------------------
   39|  48.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  48.0k|            return true;
   41|  48.0k|         }
   42|  47.4k|         return Default;
   43|  95.4k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  8.04k|      {
   38|  8.04k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 6.87k, False: 1.17k]
  ------------------
   39|  6.87k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  6.87k|            return true;
   41|  6.87k|         }
   42|  1.17k|         return Default;
   43|  8.04k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  7.78M|      {
   38|  7.78M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 156k, False: 7.62M]
  ------------------
   39|   156k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   156k|            return true;
   41|   156k|         }
   42|  7.62M|         return Default;
   43|  7.78M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_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: 71.9k, False: 84.7k]
  ------------------
   39|  71.9k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  71.9k|            return true;
   41|  71.9k|         }
   42|  84.7k|         return Default;
   43|   156k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|  84.7k|      {
   38|  84.7k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 25.2k, False: 59.5k]
  ------------------
   39|  25.2k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  25.2k|            return true;
   41|  25.2k|         }
   42|  59.5k|         return Default;
   43|  84.7k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  5.25k|      {
   38|  5.25k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 4.69k, False: 562]
  ------------------
   39|  4.69k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  4.69k|            return true;
   41|  4.69k|         }
   42|    562|         return Default;
   43|  5.25k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  2.50M|      {
   38|  2.50M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 8.81k, False: 2.49M]
  ------------------
   39|  8.81k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  8.81k|            return true;
   41|  8.81k|         }
   42|  2.49M|         return Default;
   43|  2.50M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|  8.81k|      {
   38|  8.81k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 2.40k, False: 6.41k]
  ------------------
   39|  2.40k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  2.40k|            return true;
   41|  2.40k|         }
   42|  6.41k|         return Default;
   43|  8.81k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|  6.41k|      {
   38|  6.41k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 3.07k, False: 3.33k]
  ------------------
   39|  3.07k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  3.07k|            return true;
   41|  3.07k|         }
   42|  3.33k|         return Default;
   43|  6.41k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  6.86k|      {
   38|  6.86k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.81k, False: 1.04k]
  ------------------
   39|  5.81k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.81k|            return true;
   41|  5.81k|         }
   42|  1.04k|         return Default;
   43|  6.86k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  6.18M|      {
   38|  6.18M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 61.8k, False: 6.12M]
  ------------------
   39|  61.8k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  61.8k|            return true;
   41|  61.8k|         }
   42|  6.12M|         return Default;
   43|  6.18M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|  61.8k|      {
   38|  61.8k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 27.0k, False: 34.7k]
  ------------------
   39|  27.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  27.0k|            return true;
   41|  27.0k|         }
   42|  34.7k|         return Default;
   43|  61.8k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|  34.7k|      {
   38|  34.7k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 13.9k, False: 20.8k]
  ------------------
   39|  13.9k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  13.9k|            return true;
   41|  13.9k|         }
   42|  20.8k|         return Default;
   43|  34.7k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  5.91k|      {
   38|  5.91k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.16k, False: 744]
  ------------------
   39|  5.16k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.16k|            return true;
   41|  5.16k|         }
   42|    744|         return Default;
   43|  5.91k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_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: 92.0k, False: 7.24M]
  ------------------
   39|  92.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  92.0k|            return true;
   41|  92.0k|         }
   42|  7.24M|         return Default;
   43|  7.34M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|  92.0k|      {
   38|  92.0k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 21.2k, False: 70.7k]
  ------------------
   39|  21.2k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  21.2k|            return true;
   41|  21.2k|         }
   42|  70.7k|         return Default;
   43|  92.0k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|  70.7k|      {
   38|  70.7k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 29.8k, False: 40.8k]
  ------------------
   39|  29.8k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  29.8k|            return true;
   41|  29.8k|         }
   42|  40.8k|         return Default;
   43|  70.7k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc40EEEEJNS0_5untilINS4_IJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   37|   640k|      {
   38|   640k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 35.4k, False: 605k]
  ------------------
   39|  35.4k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  35.4k|            return true;
   41|  35.4k|         }
   42|   605k|         return Default;
   43|   640k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc41EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  44.7M|      {
   38|  44.7M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 174k, False: 44.5M]
  ------------------
   39|   174k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   174k|            return true;
   41|   174k|         }
   42|  44.5M|         return Default;
   43|  44.7M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|   174k|      {
   38|   174k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 29.0k, False: 145k]
  ------------------
   39|  29.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  29.0k|            return true;
   41|  29.0k|         }
   42|   145k|         return Default;
   43|   174k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|   145k|      {
   38|   145k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 29.1k, False: 116k]
  ------------------
   39|  29.1k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  29.1k|            return true;
   41|  29.1k|         }
   42|   116k|         return Default;
   43|   145k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc34EEEEJNS0_5untilIS5_JN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  7.00k|      {
   38|  7.00k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 6.14k, False: 865]
  ------------------
   39|  6.14k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  6.14k|            return true;
   41|  6.14k|         }
   42|    865|         return Default;
   43|  7.00k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc92EEEEJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS8_15escaped_decbyteENS8_14escaped_singleENS4_IJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   37|  10.6M|      {
   38|  10.6M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 110k, False: 10.4M]
  ------------------
   39|   110k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   110k|            return true;
   41|   110k|         }
   42|  10.4M|         return Default;
   43|  10.6M|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii3oneIJLc120EEEEJNS0_3repILj2EJNS3_6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   37|   110k|      {
   38|   110k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 42.1k, False: 68.1k]
  ------------------
   39|  42.1k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  42.1k|            return true;
   41|  42.1k|         }
   42|  68.1k|         return Default;
   43|   110k|      }
_ZN3tao5pegtl8internal7if_mustILb0ENS0_5ascii5digitEJNS0_7rep_optILj2EJS4_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   37|  68.1k|      {
   38|  68.1k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 35.3k, False: 32.7k]
  ------------------
   39|  35.3k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  35.3k|            return true;
   41|  35.3k|         }
   42|  32.7k|         return Default;
   43|  68.1k|      }

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

_ZN3tao5pegtl8internal8iteratorC2EPKc:
   19|  38.4k|         : data( in_data )
   20|  38.4k|      {}

_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE2EEC2ERKS3_:
   19|   594M|      {}
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EEC2ERS3_:
   42|  8.51M|         : m_saved( i ),
   43|  8.51M|           m_input( &i )
   44|  8.51M|      {}
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EEclEb:
   60|  5.84M|      {
   61|  5.84M|         if( result ) {
  ------------------
  |  Branch (61:14): [True: 5.12M, False: 727k]
  ------------------
   62|  5.12M|            m_input = nullptr;
   63|  5.12M|            return true;
   64|  5.12M|         }
   65|   727k|         return false;
   66|  5.84M|      }
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EE8iteratorEv:
   69|  2.19M|      {
   70|  2.19M|         return m_saved;
   71|  2.19M|      }
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE0EEC2ERKS3_:
   19|  2.68M|      {}
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE0EEclEb:
   30|  2.67M|      {
   31|  2.67M|         return result;
   32|  2.67M|      }
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EED2Ev:
   50|  8.51M|      {
   51|  8.51M|         if( m_input != nullptr ) {
  ------------------
  |  Branch (51:14): [True: 3.38M, False: 5.12M]
  ------------------
   52|  3.38M|            ( *m_input ) = m_saved;
   53|  3.38M|         }
   54|  8.51M|      }
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE2EEclEb:
   30|   593M|      {
   31|   593M|         return result;
   32|   593M|      }

_ZN3tao5pegtl8internal4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNSG_4RuleEEEEbRT3_DpOT4_:
   55|  10.3k|      {
   56|  10.3k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 10.3k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  10.3k|         return true;
   60|  10.3k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|   311k|      {
   56|   311k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 208, False: 311k]
  ------------------
   57|    208|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    208|         }
   59|   311k|         return true;
   60|   311k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|   264k|      {
   56|   264k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 56, False: 264k]
  ------------------
   57|     56|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     56|         }
   59|   264k|         return true;
   60|   264k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|   117k|      {
   56|   117k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 27, False: 117k]
  ------------------
   57|     27|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     27|         }
   59|   117k|         return true;
   60|   117k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  39.4k|      {
   56|  39.4k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 39.4k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  39.4k|         return true;
   60|  39.4k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  7.50k|      {
   56|  7.50k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 210, False: 7.29k]
  ------------------
   57|    210|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    210|         }
   59|  7.50k|         return true;
   60|  7.50k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|   143k|      {
   56|   143k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 61, False: 143k]
  ------------------
   57|     61|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     61|         }
   59|   143k|         return true;
   60|   143k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  48.1k|      {
   56|  48.1k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 41, False: 48.0k]
  ------------------
   57|     41|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     41|         }
   59|  48.1k|         return true;
   60|  48.1k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  48.0k|      {
   56|  48.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 48.0k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  48.0k|         return true;
   60|  48.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  6.87k|      {
   56|  6.87k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 167, False: 6.70k]
  ------------------
   57|    167|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    167|         }
   59|  6.87k|         return true;
   60|  6.87k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_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: 55, False: 156k]
  ------------------
   57|     55|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     55|         }
   59|   156k|         return true;
   60|   156k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  71.9k|      {
   56|  71.9k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 31, False: 71.9k]
  ------------------
   57|     31|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     31|         }
   59|  71.9k|         return true;
   60|  71.9k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  25.2k|      {
   56|  25.2k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 25.2k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  25.2k|         return true;
   60|  25.2k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  4.69k|      {
   56|  4.69k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 164, False: 4.53k]
  ------------------
   57|    164|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    164|         }
   59|  4.69k|         return true;
   60|  4.69k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|  8.81k|      {
   56|  8.81k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 23, False: 8.78k]
  ------------------
   57|     23|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     23|         }
   59|  8.81k|         return true;
   60|  8.81k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  2.40k|      {
   56|  2.40k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 24, False: 2.37k]
  ------------------
   57|     24|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     24|         }
   59|  2.40k|         return true;
   60|  2.40k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  3.07k|      {
   56|  3.07k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 3.07k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  3.07k|         return true;
   60|  3.07k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  5.81k|      {
   56|  5.81k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 200, False: 5.61k]
  ------------------
   57|    200|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    200|         }
   59|  5.81k|         return true;
   60|  5.81k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|  61.8k|      {
   56|  61.8k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 60, False: 61.7k]
  ------------------
   57|     60|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     60|         }
   59|  61.8k|         return true;
   60|  61.8k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  27.0k|      {
   56|  27.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 25, False: 27.0k]
  ------------------
   57|     25|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     25|         }
   59|  27.0k|         return true;
   60|  27.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  13.9k|      {
   56|  13.9k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 13.9k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  13.9k|         return true;
   60|  13.9k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  5.16k|      {
   56|  5.16k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 176, False: 4.99k]
  ------------------
   57|    176|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    176|         }
   59|  5.16k|         return true;
   60|  5.16k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|  92.0k|      {
   56|  92.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 34, False: 91.9k]
  ------------------
   57|     34|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     34|         }
   59|  92.0k|         return true;
   60|  92.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  21.2k|      {
   56|  21.2k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 35, False: 21.2k]
  ------------------
   57|     35|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     35|         }
   59|  21.2k|         return true;
   60|  21.2k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  29.8k|      {
   56|  29.8k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 29.8k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  29.8k|         return true;
   60|  29.8k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  35.4k|      {
   56|  35.4k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 255, False: 35.2k]
  ------------------
   57|    255|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    255|         }
   59|  35.4k|         return true;
   60|  35.4k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|   174k|      {
   56|   174k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 62, False: 174k]
  ------------------
   57|     62|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     62|         }
   59|   174k|         return true;
   60|   174k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  29.0k|      {
   56|  29.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 41, False: 29.0k]
  ------------------
   57|     41|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     41|         }
   59|  29.0k|         return true;
   60|  29.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  29.1k|      {
   56|  29.1k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 29.1k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  29.1k|         return true;
   60|  29.1k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  6.14k|      {
   56|  6.14k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 200, False: 5.94k]
  ------------------
   57|    200|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    200|         }
   59|  6.14k|         return true;
   60|  6.14k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   55|   110k|      {
   56|   110k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 60, False: 110k]
  ------------------
   57|     60|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     60|         }
   59|   110k|         return true;
   60|   110k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  42.1k|      {
   56|  42.1k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 45, False: 42.1k]
  ------------------
   57|     45|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     45|         }
   59|  42.1k|         return true;
   60|  42.1k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  35.3k|      {
   56|  35.3k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 35.3k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  35.3k|         return true;
   60|  35.3k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3eofEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   55|  33.8k|      {
   56|  33.8k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 4.55k, False: 29.2k]
  ------------------
   57|  4.55k|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|  4.55k|         }
   59|  33.8k|         return true;
   60|  33.8k|      }

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

_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  6.20M|      {
   41|  6.20M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 6.12M, False: 71.2k]
  ------------------
   42|  6.12M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 3.75M, False: 2.37M]
  ------------------
   43|  3.75M|               bump_help< one >( in, t.size );
   44|  3.75M|               return true;
   45|  3.75M|            }
   46|  6.12M|         }
   47|  2.44M|         return false;
   48|  6.20M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEE4testEc:
   31|  6.12M|      {
   32|  8.57M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 3.68M, False: 2.44M]
  |  Branch (32:19): [True: 68.3k, False: 2.37M]
  ------------------
   33|  6.12M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  72.1k|      {
   41|  72.1k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 53.1k, False: 18.9k]
  ------------------
   42|  53.1k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 10.3k, False: 42.8k]
  ------------------
   43|  10.3k|               bump_help< one >( in, t.size );
   44|  10.3k|               return true;
   45|  10.3k|            }
   46|  53.1k|         }
   47|  61.7k|         return false;
   48|  72.1k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEE4testEc:
   31|  53.1k|      {
   32|  53.1k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  53.1k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  2.10M|      {
   41|  2.10M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 2.10M, False: 1.07k]
  ------------------
   42|  2.10M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 2.06M, False: 37.4k]
  ------------------
   43|  2.06M|               bump_help< one >( in, t.size );
   44|  2.06M|               return true;
   45|  2.06M|            }
   46|  2.10M|         }
   47|  38.4k|         return false;
   48|  2.10M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEE4testEc:
   31|  2.10M|      {
   32|  2.10M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  2.10M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  1.28M|      {
   41|  1.28M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 1.28M, False: 47]
  ------------------
   42|  1.28M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.28M, False: 94]
  ------------------
   43|  1.28M|               bump_help< one >( in, t.size );
   44|  1.28M|               return true;
   45|  1.28M|            }
   46|  1.28M|         }
   47|    141|         return false;
   48|  1.28M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEE4testEc:
   31|  1.28M|      {
   32|  1.28M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  1.28M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  37.7k|      {
   41|  37.7k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 37.3k, False: 425]
  ------------------
   42|  37.3k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 24.9k, False: 12.4k]
  ------------------
   43|  24.9k|               bump_help< one >( in, t.size );
   44|  24.9k|               return true;
   45|  24.9k|            }
   46|  37.3k|         }
   47|  12.8k|         return false;
   48|  37.7k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEE4testEc:
   31|  37.3k|      {
   32|  37.3k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  37.3k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  23.0k|      {
   41|  23.0k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 21.9k, False: 1.14k]
  ------------------
   42|  21.9k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 21.2k, False: 689]
  ------------------
   43|  21.2k|               bump_help< one >( in, t.size );
   44|  21.2k|               return true;
   45|  21.2k|            }
   46|  21.9k|         }
   47|  1.83k|         return false;
   48|  23.0k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEE4testEc:
   31|  21.9k|      {
   32|  21.9k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  21.9k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  61.7M|      {
   41|  61.7M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 61.7M, False: 1.93k]
  ------------------
   42|  61.7M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 704k, False: 61.0M]
  ------------------
   43|   704k|               bump_help< one >( in, t.size );
   44|   704k|               return true;
   45|   704k|            }
   46|  61.7M|         }
   47|  61.0M|         return false;
   48|  61.7M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEE4testEc:
   31|  61.7M|      {
   32|  61.7M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  61.7M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   105M|      {
   41|   105M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 105M, False: 1.54k]
  ------------------
   42|   105M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.01M, False: 104M]
  ------------------
   43|  1.01M|               bump_help< one >( in, t.size );
   44|  1.01M|               return true;
   45|  1.01M|            }
   46|   105M|         }
   47|   104M|         return false;
   48|   105M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEE4testEc:
   31|   105M|      {
   32|   105M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   105M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  1.01M|      {
   41|  1.01M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 1.01M, False: 101]
  ------------------
   42|  1.01M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 360k, False: 652k]
  ------------------
   43|   360k|               bump_help< one >( in, t.size );
   44|   360k|               return true;
   45|   360k|            }
   46|  1.01M|         }
   47|   652k|         return false;
   48|  1.01M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEE4testEc:
   31|  1.01M|      {
   32|  1.01M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  1.01M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   428k|      {
   41|   428k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 427k, False: 101]
  ------------------
   42|   427k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 416k, False: 11.5k]
  ------------------
   43|   416k|               bump_help< one >( in, t.size );
   44|   416k|               return true;
   45|   416k|            }
   46|   427k|         }
   47|  11.6k|         return false;
   48|   428k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEE4testEc:
   31|   427k|      {
   32|  3.82M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 0, False: 44.0k]
  |  Branch (32:19): [True: 32.5k, False: 11.5k]
  |  Branch (32:19): [True: 27.5k, False: 44.0k]
  |  Branch (32:19): [True: 53.0k, False: 71.6k]
  |  Branch (32:19): [True: 17.4k, False: 124k]
  |  Branch (32:19): [True: 22.6k, False: 142k]
  |  Branch (32:19): [True: 43.2k, False: 164k]
  |  Branch (32:19): [True: 30.0k, False: 207k]
  |  Branch (32:19): [True: 61.3k, False: 238k]
  |  Branch (32:19): [True: 85.6k, False: 299k]
  |  Branch (32:19): [True: 42.8k, False: 385k]
  ------------------
   33|   427k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   104M|      {
   41|   104M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 104M, False: 1.54k]
  ------------------
   42|   104M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 104M, False: 36]
  ------------------
   43|   104M|               bump_help< one >( in, t.size );
   44|   104M|               return true;
   45|   104M|            }
   46|   104M|         }
   47|  1.58k|         return false;
   48|   104M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEE4testEc:
   31|   104M|      {
   32|   209M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 16, False: 104M]
  |  Branch (32:19): [True: 20, False: 104M]
  ------------------
   33|   104M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   641k|      {
   41|   641k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 641k, False: 112]
  ------------------
   42|   641k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 505, False: 641k]
  ------------------
   43|    505|               bump_help< one >( in, t.size );
   44|    505|               return true;
   45|    505|            }
   46|   641k|         }
   47|   641k|         return false;
   48|   641k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEE4testEc:
   31|   641k|      {
   32|   641k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   641k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   640k|      {
   41|   640k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 639k, False: 1.04k]
  ------------------
   42|   639k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 35.4k, False: 604k]
  ------------------
   43|  35.4k|               bump_help< one >( in, t.size );
   44|  35.4k|               return true;
   45|  35.4k|            }
   46|   639k|         }
   47|   605k|         return false;
   48|   640k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEE4testEc:
   31|   639k|      {
   32|   639k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   639k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  44.7M|      {
   41|  44.7M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 44.7M, False: 262]
  ------------------
   42|  44.7M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 35.6k, False: 44.7M]
  ------------------
   43|  35.6k|               bump_help< one >( in, t.size );
   44|  35.6k|               return true;
   45|  35.6k|            }
   46|  44.7M|         }
   47|  44.7M|         return false;
   48|  44.7M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEE4testEc:
   31|  44.7M|      {
   32|  44.7M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  44.7M|      }

_ZN3tao5pegtl8internal3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  38.4k|      {
   47|  38.4k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  38.4k|         return true;
   49|  38.4k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   46|  38.2k|      {
   47|  38.2k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  38.2k|         return true;
   49|  38.2k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENSA_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   46|  38.2k|      {
   47|  38.2k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  38.2k|         return true;
   49|  38.2k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.85k|      {
   47|  3.85k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.85k|         return true;
   49|  3.85k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.60k|      {
   47|  3.60k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.60k|         return true;
   49|  3.60k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  4.10k|      {
   47|  4.10k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.10k|         return true;
   49|  4.10k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.53k|      {
   47|  3.53k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.53k|         return true;
   49|  3.53k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  2.89k|      {
   47|  2.89k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  2.89k|         return true;
   49|  2.89k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.43k|      {
   47|  3.43k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.43k|         return true;
   49|  3.43k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  3.38k|      {
   47|  3.38k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.38k|         return true;
   49|  3.38k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  2.82k|      {
   47|  2.82k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  2.82k|         return true;
   49|  2.82k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  5.90k|      {
   47|  5.90k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  5.90k|         return true;
   49|  5.90k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser8negationEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|   641k|      {
   47|   641k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|   641k|         return true;
   49|   641k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser18condition_argumentEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|   640k|      {
   47|   640k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|   640k|         return true;
   49|   640k|      }
_ZN3tao5pegtl8internal3optIJNS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   46|  4.22k|      {
   47|  4.22k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.22k|         return true;
   49|  4.22k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser7commentEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|  33.6k|      {
   47|  33.6k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  33.6k|         return true;
   49|  33.6k|      }

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

_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   105k|      {
   46|   105k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 80.0k, False: 25.8k]
  ------------------
   47|  85.3k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 5.22k, False: 80.0k]
  ------------------
   48|  5.22k|            }
   49|  80.0k|            return true;
   50|  80.0k|         }
   51|  25.8k|         return false;
   52|   105k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   959k|      {
   46|   959k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 958k, False: 1.11k]
  ------------------
   47|   964k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 6.46k, False: 958k]
  ------------------
   48|  6.46k|            }
   49|   958k|            return true;
   50|   958k|         }
   51|  1.11k|         return false;
   52|   959k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   315k|      {
   46|   315k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 314k, False: 1.87k]
  ------------------
   47|   317k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.20k, False: 314k]
  ------------------
   48|  3.20k|            }
   49|   314k|            return true;
   50|   314k|         }
   51|  1.87k|         return false;
   52|   315k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  11.8k|      {
   46|  11.8k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 9.97k, False: 1.87k]
  ------------------
   47|  12.0k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.09k, False: 9.97k]
  ------------------
   48|  2.09k|            }
   49|  9.97k|            return true;
   50|  9.97k|         }
   51|  1.87k|         return false;
   52|  11.8k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  10.7k|      {
   46|  10.7k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 9.22k, False: 1.53k]
  ------------------
   47|  11.2k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.02k, False: 9.22k]
  ------------------
   48|  2.02k|            }
   49|  9.22k|            return true;
   50|  9.22k|         }
   51|  1.53k|         return false;
   52|  10.7k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  8.12k|      {
   46|  8.12k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 6.59k, False: 1.52k]
  ------------------
   47|  9.38k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.79k, False: 6.59k]
  ------------------
   48|  2.79k|            }
   49|  6.59k|            return true;
   50|  6.59k|         }
   51|  1.52k|         return false;
   52|  8.12k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  9.45k|      {
   46|  9.45k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 7.94k, False: 1.51k]
  ------------------
   47|  10.6k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.74k, False: 7.94k]
  ------------------
   48|  2.74k|            }
   49|  7.94k|            return true;
   50|  7.94k|         }
   51|  1.51k|         return false;
   52|  9.45k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   170k|      {
   46|   170k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 168k, False: 1.90k]
  ------------------
   47|  1.60M|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.43M, False: 168k]
  ------------------
   48|  1.43M|            }
   49|   168k|            return true;
   50|   168k|         }
   51|  1.90k|         return false;
   52|   170k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  8.74k|      {
   46|  8.74k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 7.06k, False: 1.68k]
  ------------------
   47|  10.6k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.55k, False: 7.06k]
  ------------------
   48|  3.55k|            }
   49|  7.06k|            return true;
   50|  7.06k|         }
   51|  1.68k|         return false;
   52|  8.74k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   644k|      {
   46|   644k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 642k, False: 2.10k]
  ------------------
   47|   670k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 28.4k, False: 642k]
  ------------------
   48|  28.4k|            }
   49|   642k|            return true;
   50|   642k|         }
   51|  2.10k|         return false;
   52|   644k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  10.3k|      {
   46|  10.3k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 8.40k, False: 1.97k]
  ------------------
   47|  10.2k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.84k, False: 8.40k]
  ------------------
   48|  1.84k|            }
   49|  8.40k|            return true;
   50|  8.40k|         }
   51|  1.97k|         return false;
   52|  10.3k|      }

_ZN3tao5pegtl8internal5rangeILNS1_15result_on_foundE1ENS1_9peek_charELc48ELc57EE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   39|   917k|      {
   40|   917k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (40:25): [True: 917k, False: 176]
  ------------------
   41|   917k|            if( test( t.data ) ) {
  ------------------
  |  Branch (41:17): [True: 289k, False: 628k]
  ------------------
   42|   289k|               bump_help< range >( in, t.size );
   43|   289k|               return true;
   44|   289k|            }
   45|   917k|         }
   46|   628k|         return false;
   47|   917k|      }
_ZN3tao5pegtl8internal5rangeILNS1_15result_on_foundE1ENS1_9peek_charELc48ELc57EE4testEc:
   30|   917k|      {
   31|   917k|         return ( ( Lo <= c ) && ( c <= Hi ) ) == bool( R );
  ------------------
  |  Branch (31:19): [True: 696k, False: 221k]
  |  Branch (31:34): [True: 289k, False: 407k]
  ------------------
   32|   917k|      }

_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|  3.52M|      {
   60|  3.52M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 3.51M, False: 1.36k]
  ------------------
   61|  3.51M|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 1.41M, False: 2.10M]
  ------------------
   62|  1.41M|               bump_help< ranges >( in, t.size );
   63|  1.41M|               return true;
   64|  1.41M|            }
   65|  3.51M|         }
   66|  2.10M|         return false;
   67|  3.52M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE4testEc:
   50|  3.51M|      {
   51|  3.51M|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|  3.51M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE4testIJLm0ELm1ELm2EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|  3.51M|      {
   40|  3.51M|         constexpr const data_t cs[] = { Cs... };
   41|  3.51M|         if constexpr( sizeof...( Cs ) % 2 == 0 ) {
   42|  12.7M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... );
  ------------------
  |  Branch (42:22): [True: 391k, False: 2.81M]
  |  Branch (42:22): [True: 712k, False: 2.10M]
  |  Branch (42:22): [True: 308k, False: 3.21M]
  ------------------
   43|       |         }
   44|       |         else {
   45|       |            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
   46|       |         }
   47|  3.51M|      }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc48ETnS3_Lc57EEEbS3_:
   23|  4.19M|   {
   24|  4.19M|      static_assert( Lo <= Hi, "invalid range" );
   25|  4.19M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 1.45M, False: 2.74M]
  |  Branch (25:29): [True: 313k, False: 1.14M]
  ------------------
   26|  4.19M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc97ETnS3_Lc102EEEbS3_:
   23|  3.21M|   {
   24|  3.21M|      static_assert( Lo <= Hi, "invalid range" );
   25|  3.21M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 428k, False: 2.78M]
  |  Branch (25:29): [True: 391k, False: 36.7k]
  ------------------
   26|  3.21M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc65ETnS3_Lc70EEEbS3_:
   23|  2.81M|   {
   24|  2.81M|      static_assert( Lo <= Hi, "invalid range" );
   25|  2.81M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 749k, False: 2.07M]
  |  Branch (25:29): [True: 712k, False: 36.8k]
  ------------------
   26|  2.81M|   }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|   641k|      {
   60|   641k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 641k, False: 120]
  ------------------
   61|   641k|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 640k, False: 1.13k]
  ------------------
   62|   640k|               bump_help< ranges >( in, t.size );
   63|   640k|               return true;
   64|   640k|            }
   65|   641k|         }
   66|  1.25k|         return false;
   67|   641k|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE4testEc:
   50|   641k|      {
   51|   641k|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|   641k|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE4testIJLm0ELm1EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|   641k|      {
   40|   641k|         constexpr const data_t cs[] = { Cs... };
   41|       |         if constexpr( sizeof...( Cs ) % 2 == 0 ) {
   42|       |            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... );
   43|       |         }
   44|   641k|         else {
   45|  1.28M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
  ------------------
  |  Branch (45:22): [True: 640k, False: 1.23k]
  |  Branch (45:22): [True: 63, False: 1.17k]
  |  Branch (45:96): [True: 32, False: 1.13k]
  ------------------
   46|   641k|         }
   47|   641k|      }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc97ETnS3_Lc122EEEbS3_:
   23|  30.1M|   {
   24|  30.1M|      static_assert( Lo <= Hi, "invalid range" );
   25|  30.1M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 5.44M, False: 24.6M]
  |  Branch (25:29): [True: 5.44M, False: 2.50k]
  ------------------
   26|  30.1M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc65ETnS3_Lc90EEEbS3_:
   23|  24.6M|   {
   24|  24.6M|      static_assert( Lo <= Hi, "invalid range" );
   25|  24.6M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 23.9M, False: 678k]
  |  Branch (25:29): [True: 23.9M, False: 2.52k]
  ------------------
   26|  24.6M|   }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|  29.4M|      {
   60|  29.4M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 29.4M, False: 1.04k]
  ------------------
   61|  29.4M|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 28.8M, False: 639k]
  ------------------
   62|  28.8M|               bump_help< ranges >( in, t.size );
   63|  28.8M|               return true;
   64|  28.8M|            }
   65|  29.4M|         }
   66|   640k|         return false;
   67|  29.4M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE4testEc:
   50|  29.4M|      {
   51|  29.4M|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|  29.4M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE4testIJLm0ELm1ELm2EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|  29.4M|      {
   40|  29.4M|         constexpr const data_t cs[] = { Cs... };
   41|       |         if constexpr( sizeof...( Cs ) % 2 == 0 ) {
   42|       |            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... );
   43|       |         }
   44|  29.4M|         else {
   45|   108M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
  ------------------
  |  Branch (45:22): [True: 23.9M, False: 679k]
  |  Branch (45:22): [True: 5.19k, False: 674k]
  |  Branch (45:22): [True: 4.80M, False: 24.6M]
  |  Branch (45:96): [True: 34.9k, False: 639k]
  ------------------
   46|  29.4M|         }
   47|  29.4M|      }

_ZN3tao5pegtl8internal3repILj4EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  40.0k|      {
   50|  40.0k|         auto m = in.template mark< M >();
   51|  40.0k|         using m_t = decltype( m );
   52|       |
   53|  47.7k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 45.8k, False: 1.90k]
  ------------------
   54|  45.8k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 38.1k, False: 7.67k]
  ------------------
   55|  38.1k|               return false;
   56|  38.1k|            }
   57|  45.8k|         }
   58|  1.90k|         return m( true );
   59|  40.0k|      }
_ZN3tao5pegtl8internal3repILj4EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  1.91M|      {
   50|  1.91M|         auto m = in.template mark< M >();
   51|  1.91M|         using m_t = decltype( m );
   52|       |
   53|  1.92M|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 1.91M, False: 2.35k]
  ------------------
   54|  1.91M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 1.90M, False: 9.58k]
  ------------------
   55|  1.90M|               return false;
   56|  1.90M|            }
   57|  1.91M|         }
   58|  2.35k|         return m( true );
   59|  1.91M|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   117k|      {
   50|   117k|         auto m = in.template mark< M >();
   51|   117k|         using m_t = decltype( m );
   52|       |
   53|   353k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 235k, False: 117k]
  ------------------
   54|   235k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 27, False: 235k]
  ------------------
   55|     27|               return false;
   56|     27|            }
   57|   235k|         }
   58|   117k|         return m( true );
   59|   117k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  48.1k|      {
   50|  48.1k|         auto m = in.template mark< M >();
   51|  48.1k|         using m_t = decltype( m );
   52|       |
   53|   144k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 96.1k, False: 48.0k]
  ------------------
   54|  96.1k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 41, False: 96.1k]
  ------------------
   55|     41|               return false;
   56|     41|            }
   57|  96.1k|         }
   58|  48.0k|         return m( true );
   59|  48.1k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  71.9k|      {
   50|  71.9k|         auto m = in.template mark< M >();
   51|  71.9k|         using m_t = decltype( m );
   52|       |
   53|   215k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 143k, False: 71.9k]
  ------------------
   54|   143k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 31, False: 143k]
  ------------------
   55|     31|               return false;
   56|     31|            }
   57|   143k|         }
   58|  71.9k|         return m( true );
   59|  71.9k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  2.40k|      {
   50|  2.40k|         auto m = in.template mark< M >();
   51|  2.40k|         using m_t = decltype( m );
   52|       |
   53|  7.16k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 4.79k, False: 2.37k]
  ------------------
   54|  4.79k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 24, False: 4.76k]
  ------------------
   55|     24|               return false;
   56|     24|            }
   57|  4.79k|         }
   58|  2.37k|         return m( true );
   59|  2.40k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  27.0k|      {
   50|  27.0k|         auto m = in.template mark< M >();
   51|  27.0k|         using m_t = decltype( m );
   52|       |
   53|  81.2k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 54.1k, False: 27.0k]
  ------------------
   54|  54.1k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 25, False: 54.1k]
  ------------------
   55|     25|               return false;
   56|     25|            }
   57|  54.1k|         }
   58|  27.0k|         return m( true );
   59|  27.0k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   166k|      {
   50|   166k|         auto m = in.template mark< M >();
   51|   166k|         using m_t = decltype( m );
   52|       |
   53|   498k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 332k, False: 165k]
  ------------------
   54|   332k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 937, False: 332k]
  ------------------
   55|    937|               return false;
   56|    937|            }
   57|   332k|         }
   58|   165k|         return m( true );
   59|   166k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   331k|      {
   50|   331k|         auto m = in.template mark< M >();
   51|   331k|         using m_t = decltype( m );
   52|       |
   53|   675k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 503k, False: 171k]
  ------------------
   54|   503k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 159k, False: 343k]
  ------------------
   55|   159k|               return false;
   56|   159k|            }
   57|   503k|         }
   58|   171k|         return m( true );
   59|   331k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  21.2k|      {
   50|  21.2k|         auto m = in.template mark< M >();
   51|  21.2k|         using m_t = decltype( m );
   52|       |
   53|  63.8k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 42.5k, False: 21.2k]
  ------------------
   54|  42.5k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 35, False: 42.5k]
  ------------------
   55|     35|               return false;
   56|     35|            }
   57|  42.5k|         }
   58|  21.2k|         return m( true );
   59|  21.2k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  29.0k|      {
   50|  29.0k|         auto m = in.template mark< M >();
   51|  29.0k|         using m_t = decltype( m );
   52|       |
   53|  87.1k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 58.1k, False: 29.0k]
  ------------------
   54|  58.1k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 41, False: 58.0k]
  ------------------
   55|     41|               return false;
   56|     41|            }
   57|  58.1k|         }
   58|  29.0k|         return m( true );
   59|  29.0k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  42.1k|      {
   50|  42.1k|         auto m = in.template mark< M >();
   51|  42.1k|         using m_t = decltype( m );
   52|       |
   53|   126k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 84.3k, False: 42.1k]
  ------------------
   54|  84.3k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 45, False: 84.3k]
  ------------------
   55|     45|               return false;
   56|     45|            }
   57|  84.3k|         }
   58|  42.1k|         return m( true );
   59|  42.1k|      }

_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  39.4k|      {
   50|  47.6k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 44.9k, False: 2.66k]
  |  Branch (50:47): [True: 8.20k, False: 36.7k]
  ------------------
   51|  8.20k|         }
   52|  39.4k|         return true;
   53|  39.4k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  48.0k|      {
   50|  57.6k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 53.4k, False: 4.26k]
  |  Branch (50:47): [True: 9.65k, False: 43.7k]
  ------------------
   51|  9.65k|         }
   52|  48.0k|         return true;
   53|  48.0k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  25.2k|      {
   50|  40.7k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 33.8k, False: 6.89k]
  |  Branch (50:47): [True: 15.5k, False: 18.3k]
  ------------------
   51|  15.5k|         }
   52|  25.2k|         return true;
   53|  25.2k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  3.07k|      {
   50|  4.16k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 3.67k, False: 486]
  |  Branch (50:47): [True: 1.08k, False: 2.59k]
  ------------------
   51|  1.08k|         }
   52|  3.07k|         return true;
   53|  3.07k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  13.9k|      {
   50|  21.5k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 18.3k, False: 3.17k]
  |  Branch (50:47): [True: 7.64k, False: 10.7k]
  ------------------
   51|  7.64k|         }
   52|  13.9k|         return true;
   53|  13.9k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  29.8k|      {
   50|  34.9k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 33.8k, False: 1.06k]
  |  Branch (50:47): [True: 5.01k, False: 28.8k]
  ------------------
   51|  5.01k|         }
   52|  29.8k|         return true;
   53|  29.8k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  29.1k|      {
   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: 35.9k, False: 1.65k]
  |  Branch (50:47): [True: 8.45k, False: 27.5k]
  ------------------
   51|  8.45k|         }
   52|  29.1k|         return true;
   53|  29.1k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  35.3k|      {
   50|  44.6k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 41.1k, False: 3.51k]
  |  Branch (50:47): [True: 9.30k, False: 31.8k]
  ------------------
   51|  9.30k|         }
   52|  35.3k|         return true;
   53|  35.3k|      }

_ZN3tao5pegtl8internal3seqIJNS0_4starINS0_5ascii5blankEJEEENS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENSA_4ruleEEEEEEENS0_4mustIJNS0_3eofEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENSA_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSS_11char_traitsIcEENSS_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   41|  38.4k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  38.4k|         else {
   46|  38.4k|            auto m = in.template mark< M >();
   47|  38.4k|            using m_t = decltype( m );
   48|   149k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 33.8k, False: 4.62k]
  |  Branch (48:25): [True: 29.2k, False: 4.55k]
  |  Branch (48:25): [True: 38.4k, False: 0]
  ------------------
   49|  38.4k|         }
   50|  38.4k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4starINS0_5ascii5blankEJEEENS0_7if_mustINS4_3oneIJLc35EEEEJNS3_INS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS4_3anyEEEEJEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNSM_4RuleEEEEbRT3_DpOT4_:
   41|  72.1k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  72.1k|         else {
   46|  72.1k|            auto m = in.template mark< M >();
   47|  72.1k|            using m_t = decltype( m );
   48|   144k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 72.1k, False: 0]
  |  Branch (48:25): [True: 10.3k, False: 61.7k]
  ------------------
   49|  72.1k|         }
   50|  72.1k|      }
_ZN3tao5pegtl8internal3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSC_4RuleEEEEbRT3_DpOT4_:
   41|   523k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   523k|         else {
   46|   523k|            auto m = in.template mark< M >();
   47|   523k|            using m_t = decltype( m );
   48|  1.03M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 513k, False: 10.3k]
  |  Branch (48:25): [True: 513k, False: 0]
  ------------------
   49|   523k|         }
   50|   523k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser6targetENS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS4_9device_idEEEENS6_IJSA_NS0_4listINS4_15rule_attributesESA_vEEEEENS6_IJNS4_7commentEEEENS0_4starIS9_JEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSV_11char_traitsIcEENSV_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  38.4k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  38.4k|         else {
   46|  38.4k|            auto m = in.template mark< M >();
   47|  38.4k|            using m_t = decltype( m );
   48|   292k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 33.6k, False: 0]
  |  Branch (48:25): [True: 33.6k, False: 0]
  |  Branch (48:25): [True: 33.6k, False: 4.62k]
  |  Branch (48:25): [True: 38.2k, False: 2]
  |  Branch (48:25): [True: 38.2k, False: 104]
  ------------------
   49|  38.4k|         }
   50|  38.4k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  38.2k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  38.2k|         else {
   46|  38.2k|            auto m = in.template mark< M >();
   47|  38.2k|            using m_t = decltype( m );
   48|  76.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 38.2k, False: 28]
  |  Branch (48:25): [True: 1.75k, False: 36.5k]
  ------------------
   49|  38.2k|         }
   50|  38.2k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser10device_vidENS0_5ascii3oneIJLc58EEEENS4_10device_pidEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  38.2k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  38.2k|         else {
   46|  38.2k|            auto m = in.template mark< M >();
   47|  38.2k|            using m_t = decltype( m );
   48|  43.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.76k, False: 25]
  |  Branch (48:25): [True: 1.75k, False: 8]
  |  Branch (48:25): [True: 1.78k, False: 36.4k]
  ------------------
   49|  38.2k|         }
   50|  38.2k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   41|  38.2k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  38.2k|         else {
   46|  38.2k|            auto m = in.template mark< M >();
   47|  38.2k|            using m_t = decltype( m );
   48|  75.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 37.0k, False: 1.23k]
  |  Branch (48:25): [True: 25.9k, False: 11.0k]
  ------------------
   49|  38.2k|         }
   50|  38.2k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser15rule_attributesENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  37.0k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  37.0k|         else {
   46|  37.0k|            auto m = in.template mark< M >();
   47|  37.0k|            using m_t = decltype( m );
   48|  63.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 26.2k, False: 10.7k]
  |  Branch (48:25): [True: 25.9k, False: 299]
  ------------------
   49|  37.0k|         }
   50|  37.0k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser6str_idENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_15device_id_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  41.8k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  41.8k|         else {
   46|  41.8k|            auto m = in.template mark< M >();
   47|  41.8k|            using m_t = decltype( m );
   48|  53.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.85k, False: 18]
  |  Branch (48:25): [True: 3.38k, False: 473]
  |  Branch (48:25): [True: 3.87k, False: 37.9k]
  ------------------
   49|  41.8k|         }
   50|  41.8k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_15device_id_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.85k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.85k|         else {
   46|  3.85k|            auto m = in.template mark< M >();
   47|  3.85k|            using m_t = decltype( m );
   48|  29.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.51k, False: 0]
  |  Branch (48:25): [True: 2.35k, False: 161]
  |  Branch (48:25): [True: 2.51k, False: 78]
  |  Branch (48:25): [True: 2.59k, False: 0]
  |  Branch (48:25): [True: 2.59k, False: 1.26k]
  |  Branch (48:25): [True: 3.85k, False: 0]
  ------------------
   49|  3.85k|         }
   50|  3.85k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.85k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.85k|         else {
   46|  3.85k|            auto m = in.template mark< M >();
   47|  3.85k|            using m_t = decltype( m );
   48|  5.83k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.97k, False: 1.88k]
  |  Branch (48:25): [True: 1.93k, False: 43]
  ------------------
   49|  3.85k|         }
   50|  3.85k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser15device_id_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.59k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.59k|         else {
   46|  2.59k|            auto m = in.template mark< M >();
   47|  2.59k|            using m_t = decltype( m );
   48|  5.10k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.51k, False: 75]
  |  Branch (48:25): [True: 2.51k, False: 3]
  ------------------
   49|  2.59k|         }
   50|  2.59k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15device_id_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|   953k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   953k|         else {
   46|   953k|            auto m = in.template mark< M >();
   47|   953k|            using m_t = decltype( m );
   48|  1.90M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 952k, False: 1.05k]
  |  Branch (48:25): [True: 951k, False: 1.46k]
  ------------------
   49|   953k|         }
   50|   953k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser10device_vidENS0_5ascii3oneIJLc58EEEENS4_10device_pidEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|   956k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   956k|         else {
   46|   956k|            auto m = in.template mark< M >();
   47|   956k|            using m_t = decltype( m );
   48|  3.82M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 954k, False: 51]
  |  Branch (48:25): [True: 954k, False: 24]
  |  Branch (48:25): [True: 954k, False: 1.92k]
  ------------------
   49|   956k|         }
   50|   956k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser8str_nameENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  38.4k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  38.4k|         else {
   46|  38.4k|            auto m = in.template mark< M >();
   47|  38.4k|            using m_t = decltype( m );
   48|  49.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.60k, False: 17]
  |  Branch (48:25): [True: 2.90k, False: 706]
  |  Branch (48:25): [True: 3.62k, False: 34.7k]
  ------------------
   49|  38.4k|         }
   50|  38.4k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.60k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.60k|         else {
   46|  3.60k|            auto m = in.template mark< M >();
   47|  3.60k|            using m_t = decltype( m );
   48|  27.8k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.39k, False: 0]
  |  Branch (48:25): [True: 2.26k, False: 132]
  |  Branch (48:25): [True: 2.39k, False: 74]
  |  Branch (48:25): [True: 2.46k, False: 0]
  |  Branch (48:25): [True: 2.46k, False: 1.13k]
  |  Branch (48:25): [True: 3.60k, False: 0]
  ------------------
   49|  3.60k|         }
   50|  3.60k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.60k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.60k|         else {
   46|  3.60k|            auto m = in.template mark< M >();
   47|  3.60k|            using m_t = decltype( m );
   48|  5.13k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.53k, False: 2.07k]
  |  Branch (48:25): [True: 1.48k, False: 42]
  ------------------
   49|  3.60k|         }
   50|  3.60k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.46k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.46k|         else {
   46|  2.46k|            auto m = in.template mark< M >();
   47|  2.46k|            using m_t = decltype( m );
   48|  4.87k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.41k, False: 59]
  |  Branch (48:25): [True: 2.39k, False: 15]
  ------------------
   49|  2.46k|         }
   50|  2.46k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|   310k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   310k|         else {
   46|   310k|            auto m = in.template mark< M >();
   47|   310k|            using m_t = decltype( m );
   48|   619k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 308k, False: 1.81k]
  |  Branch (48:25): [True: 308k, False: 594]
  ------------------
   49|   310k|         }
   50|   310k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser8str_hashENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  35.1k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  35.1k|         else {
   46|  35.1k|            auto m = in.template mark< M >();
   47|  35.1k|            using m_t = decltype( m );
   48|  47.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.10k, False: 19]
  |  Branch (48:25): [True: 3.38k, False: 726]
  |  Branch (48:25): [True: 4.12k, False: 31.0k]
  ------------------
   49|  35.1k|         }
   50|  35.1k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  4.10k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.10k|         else {
   46|  4.10k|            auto m = in.template mark< M >();
   47|  4.10k|            using m_t = decltype( m );
   48|  31.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.65k, False: 0]
  |  Branch (48:25): [True: 2.52k, False: 126]
  |  Branch (48:25): [True: 2.65k, False: 88]
  |  Branch (48:25): [True: 2.74k, False: 0]
  |  Branch (48:25): [True: 2.74k, False: 1.36k]
  |  Branch (48:25): [True: 4.10k, False: 0]
  ------------------
   49|  4.10k|         }
   50|  4.10k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  4.10k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.10k|         else {
   46|  4.10k|            auto m = in.template mark< M >();
   47|  4.10k|            using m_t = decltype( m );
   48|  5.55k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.44k, False: 2.66k]
  |  Branch (48:25): [True: 1.40k, False: 42]
  ------------------
   49|  4.10k|         }
   50|  4.10k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.74k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.74k|         else {
   46|  2.74k|            auto m = in.template mark< M >();
   47|  2.74k|            using m_t = decltype( m );
   48|  5.41k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.67k, False: 68]
  |  Branch (48:25): [True: 2.65k, False: 20]
  ------------------
   49|  2.74k|         }
   50|  2.74k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  6.27k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  6.27k|         else {
   46|  6.27k|            auto m = in.template mark< M >();
   47|  6.27k|            using m_t = decltype( m );
   48|  10.7k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.46k, False: 1.81k]
  |  Branch (48:25): [True: 3.59k, False: 864]
  ------------------
   49|  6.27k|         }
   50|  6.27k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser15str_parent_hashENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  31.3k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  31.3k|         else {
   46|  31.3k|            auto m = in.template mark< M >();
   47|  31.3k|            using m_t = decltype( m );
   48|  42.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.53k, False: 14]
  |  Branch (48:25): [True: 2.90k, False: 631]
  |  Branch (48:25): [True: 3.55k, False: 27.8k]
  ------------------
   49|  31.3k|         }
   50|  31.3k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.53k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.53k|         else {
   46|  3.53k|            auto m = in.template mark< M >();
   47|  3.53k|            using m_t = decltype( m );
   48|  26.8k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.28k, False: 0]
  |  Branch (48:25): [True: 2.14k, False: 138]
  |  Branch (48:25): [True: 2.28k, False: 73]
  |  Branch (48:25): [True: 2.35k, False: 0]
  |  Branch (48:25): [True: 2.35k, False: 1.18k]
  |  Branch (48:25): [True: 3.53k, False: 0]
  ------------------
   49|  3.53k|         }
   50|  3.53k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.53k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.53k|         else {
   46|  3.53k|            auto m = in.template mark< M >();
   47|  3.53k|            using m_t = decltype( m );
   48|  4.93k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.39k, False: 2.14k]
  |  Branch (48:25): [True: 1.35k, False: 43]
  ------------------
   49|  3.53k|         }
   50|  3.53k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.35k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.35k|         else {
   46|  2.35k|            auto m = in.template mark< M >();
   47|  2.35k|            using m_t = decltype( m );
   48|  4.66k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.30k, False: 54]
  |  Branch (48:25): [True: 2.28k, False: 19]
  ------------------
   49|  2.35k|         }
   50|  2.35k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  5.81k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  5.81k|         else {
   46|  5.81k|            auto m = in.template mark< M >();
   47|  5.81k|            using m_t = decltype( m );
   48|  10.1k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.33k, False: 1.48k]
  |  Branch (48:25): [True: 3.50k, False: 823]
  ------------------
   49|  5.81k|         }
   50|  5.81k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser10str_serialENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  28.1k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  28.1k|         else {
   46|  28.1k|            auto m = in.template mark< M >();
   47|  28.1k|            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: 2.89k, False: 15]
  |  Branch (48:25): [True: 2.42k, False: 463]
  |  Branch (48:25): [True: 2.90k, False: 25.2k]
  ------------------
   49|  28.1k|         }
   50|  28.1k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  2.89k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.89k|         else {
   46|  2.89k|            auto m = in.template mark< M >();
   47|  2.89k|            using m_t = decltype( m );
   48|  21.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.76k, False: 0]
  |  Branch (48:25): [True: 1.67k, False: 95]
  |  Branch (48:25): [True: 1.76k, False: 48]
  |  Branch (48:25): [True: 1.81k, False: 0]
  |  Branch (48:25): [True: 1.81k, False: 1.07k]
  |  Branch (48:25): [True: 2.89k, False: 0]
  ------------------
   49|  2.89k|         }
   50|  2.89k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.89k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.89k|         else {
   46|  2.89k|            auto m = in.template mark< M >();
   47|  2.89k|            using m_t = decltype( m );
   48|  4.38k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.49k, False: 1.39k]
  |  Branch (48:25): [True: 1.46k, False: 34]
  ------------------
   49|  2.89k|         }
   50|  2.89k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  1.81k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  1.81k|         else {
   46|  1.81k|            auto m = in.template mark< M >();
   47|  1.81k|            using m_t = decltype( m );
   48|  3.59k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.77k, False: 39]
  |  Branch (48:25): [True: 1.76k, False: 9]
  ------------------
   49|  1.81k|         }
   50|  1.81k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  3.71k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.71k|         else {
   46|  3.71k|            auto m = in.template mark< M >();
   47|  3.71k|            using m_t = decltype( m );
   48|  5.95k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.24k, False: 1.47k]
  |  Branch (48:25): [True: 1.94k, False: 300]
  ------------------
   49|  3.71k|         }
   50|  3.71k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12str_via_portENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  25.4k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  25.4k|         else {
   46|  25.4k|            auto m = in.template mark< M >();
   47|  25.4k|            using m_t = decltype( m );
   48|  35.8k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.43k, False: 16]
  |  Branch (48:25): [True: 2.78k, False: 655]
  |  Branch (48:25): [True: 3.45k, False: 22.0k]
  ------------------
   49|  25.4k|         }
   50|  25.4k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.43k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.43k|         else {
   46|  3.43k|            auto m = in.template mark< M >();
   47|  3.43k|            using m_t = decltype( m );
   48|  25.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.12k, False: 0]
  |  Branch (48:25): [True: 1.99k, False: 127]
  |  Branch (48:25): [True: 2.12k, False: 70]
  |  Branch (48:25): [True: 2.19k, False: 0]
  |  Branch (48:25): [True: 2.19k, False: 1.24k]
  |  Branch (48:25): [True: 3.43k, False: 0]
  ------------------
   49|  3.43k|         }
   50|  3.43k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.43k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.43k|         else {
   46|  3.43k|            auto m = in.template mark< M >();
   47|  3.43k|            using m_t = decltype( m );
   48|  4.73k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.30k, False: 2.13k]
  |  Branch (48:25): [True: 1.25k, False: 46]
  ------------------
   49|  3.43k|         }
   50|  3.43k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.19k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.19k|         else {
   46|  2.19k|            auto m = in.template mark< M >();
   47|  2.19k|            using m_t = decltype( m );
   48|  4.33k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.13k, False: 57]
  |  Branch (48:25): [True: 2.12k, False: 13]
  ------------------
   49|  2.19k|         }
   50|  2.19k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  4.70k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.70k|         else {
   46|  4.70k|            auto m = in.template mark< M >();
   47|  4.70k|            using m_t = decltype( m );
   48|  7.95k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.25k, False: 1.44k]
  |  Branch (48:25): [True: 2.56k, False: 691]
  ------------------
   49|  4.70k|         }
   50|  4.70k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser18str_with_interfaceENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_15interface_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  22.3k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  22.3k|         else {
   46|  22.3k|            auto m = in.template mark< M >();
   47|  22.3k|            using m_t = decltype( m );
   48|  32.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.38k, False: 6]
  |  Branch (48:25): [True: 2.92k, False: 460]
  |  Branch (48:25): [True: 3.38k, False: 18.9k]
  ------------------
   49|  22.3k|         }
   50|  22.3k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_15interface_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  3.38k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.38k|         else {
   46|  3.38k|            auto m = in.template mark< M >();
   47|  3.38k|            using m_t = decltype( m );
   48|  27.1k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.40k, False: 0]
  |  Branch (48:25): [True: 2.21k, False: 188]
  |  Branch (48:25): [True: 2.40k, False: 51]
  |  Branch (48:25): [True: 2.45k, False: 0]
  |  Branch (48:25): [True: 2.45k, False: 925]
  |  Branch (48:25): [True: 3.38k, False: 0]
  ------------------
   49|  3.38k|         }
   50|  3.38k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.38k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.38k|         else {
   46|  3.38k|            auto m = in.template mark< M >();
   47|  3.38k|            using m_t = decltype( m );
   48|  5.28k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.90k, False: 1.47k]
  |  Branch (48:25): [True: 1.86k, False: 43]
  ------------------
   49|  3.38k|         }
   50|  3.38k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser15interface_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.45k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.45k|         else {
   46|  2.45k|            auto m = in.template mark< M >();
   47|  2.45k|            using m_t = decltype( m );
   48|  4.86k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.40k, False: 49]
  |  Branch (48:25): [True: 2.40k, False: 2]
  ------------------
   49|  2.45k|         }
   50|  2.45k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15interface_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|   165k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   165k|         else {
   46|   165k|            auto m = in.template mark< M >();
   47|   165k|            using m_t = decltype( m );
   48|   328k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 163k, False: 1.85k]
  |  Branch (48:25): [True: 162k, False: 554]
  ------------------
   49|   165k|         }
   50|   165k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser4hex2ENS0_5ascii3oneIJLc58EEEENS4_14hex2orAsteriskES8_S9_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|   166k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   166k|         else {
   46|   166k|            auto m = in.template mark< M >();
   47|   166k|            using m_t = decltype( m );
   48|  1.32M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 165k, False: 29]
  |  Branch (48:25): [True: 165k, False: 25]
  |  Branch (48:25): [True: 165k, False: 29]
  |  Branch (48:25): [True: 165k, False: 36]
  |  Branch (48:25): [True: 165k, False: 937]
  ------------------
   49|   166k|         }
   50|   166k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser21str_with_connect_typeENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  19.4k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  19.4k|         else {
   46|  19.4k|            auto m = in.template mark< M >();
   47|  19.4k|            using m_t = decltype( m );
   48|  27.9k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.82k, False: 9]
  |  Branch (48:25): [True: 2.23k, False: 591]
  |  Branch (48:25): [True: 2.83k, False: 16.6k]
  ------------------
   49|  19.4k|         }
   50|  19.4k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  2.82k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.82k|         else {
   46|  2.82k|            auto m = in.template mark< M >();
   47|  2.82k|            using m_t = decltype( m );
   48|  23.1k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.04k, False: 0]
  |  Branch (48:25): [True: 1.92k, False: 125]
  |  Branch (48:25): [True: 2.04k, False: 75]
  |  Branch (48:25): [True: 2.12k, False: 0]
  |  Branch (48:25): [True: 2.12k, False: 707]
  |  Branch (48:25): [True: 2.82k, False: 0]
  ------------------
   49|  2.82k|         }
   50|  2.82k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.82k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.82k|         else {
   46|  2.82k|            auto m = in.template mark< M >();
   47|  2.82k|            using m_t = decltype( m );
   48|  4.17k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.35k, False: 1.47k]
  |  Branch (48:25): [True: 1.30k, False: 41]
  ------------------
   49|  2.82k|         }
   50|  2.82k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.12k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.12k|         else {
   46|  2.12k|            auto m = in.template mark< M >();
   47|  2.12k|            using m_t = decltype( m );
   48|  4.17k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.05k, False: 65]
  |  Branch (48:25): [True: 2.04k, False: 10]
  ------------------
   49|  2.12k|         }
   50|  2.12k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  4.55k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.55k|         else {
   46|  4.55k|            auto m = in.template mark< M >();
   47|  4.55k|            using m_t = decltype( m );
   48|  7.48k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.92k, False: 1.63k]
  |  Branch (48:25): [True: 2.50k, False: 420]
  ------------------
   49|  4.55k|         }
   50|  4.55k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser6str_ifENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_9conditionEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  16.9k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  16.9k|         else {
   46|  16.9k|            auto m = in.template mark< M >();
   47|  16.9k|            using m_t = decltype( m );
   48|  34.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 5.90k, False: 27]
  |  Branch (48:25): [True: 2.85k, False: 3.05k]
  |  Branch (48:25): [True: 5.93k, False: 10.9k]
  ------------------
   49|  16.9k|         }
   50|  16.9k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_9conditionESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  5.90k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  5.90k|         else {
   46|  5.90k|            auto m = in.template mark< M >();
   47|  5.90k|            using m_t = decltype( m );
   48|  40.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.48k, False: 0]
  |  Branch (48:25): [True: 1.86k, False: 615]
  |  Branch (48:25): [True: 2.48k, False: 1.25k]
  |  Branch (48:25): [True: 3.73k, False: 0]
  |  Branch (48:25): [True: 3.73k, False: 2.17k]
  |  Branch (48:25): [True: 5.90k, False: 0]
  ------------------
   49|  5.90k|         }
   50|  5.90k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  5.90k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  5.90k|         else {
   46|  5.90k|            auto m = in.template mark< M >();
   47|  5.90k|            using m_t = decltype( m );
   48|  7.19k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.28k, False: 4.61k]
  |  Branch (48:25): [True: 1.19k, False: 92]
  ------------------
   49|  5.90k|         }
   50|  5.90k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser9conditionENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  3.73k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.73k|         else {
   46|  3.73k|            auto m = in.template mark< M >();
   47|  3.73k|            using m_t = decltype( m );
   48|  7.32k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.59k, False: 137]
  |  Branch (48:25): [True: 2.48k, False: 1.11k]
  ------------------
   49|  3.73k|         }
   50|  3.73k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|   637k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   637k|         else {
   46|   637k|            auto m = in.template mark< M >();
   47|   637k|            using m_t = decltype( m );
   48|  1.27M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 635k, False: 1.98k]
  |  Branch (48:25): [True: 633k, False: 1.60k]
  ------------------
   49|   637k|         }
   50|   637k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser8negationEEEENS5_20condition_identifierENS3_IJNS5_18condition_argumentEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|   641k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   641k|         else {
   46|   641k|            auto m = in.template mark< M >();
   47|   641k|            using m_t = decltype( m );
   48|  2.56M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 640k, False: 1.25k]
  |  Branch (48:25): [True: 640k, False: 358]
  |  Branch (48:25): [True: 641k, False: 0]
  ------------------
   49|   641k|         }
   50|   641k|      }
_ZN3tao5pegtl8internal3seqIJNS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEENS0_4starINS4_IJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   41|   641k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   641k|         else {
   46|   641k|            auto m = in.template mark< M >();
   47|   641k|            using m_t = decltype( m );
   48|  1.28M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 640k, False: 1.25k]
  |  Branch (48:25): [True: 640k, False: 0]
  ------------------
   49|   641k|         }
   50|   641k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser9str_labelENS0_4plusINS0_5ascii5blankEJEEENS0_3sorIJNS4_24attribute_value_multisetINS4_12string_valueEEESC_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  11.7k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  11.7k|         else {
   46|  11.7k|            auto m = in.template mark< M >();
   47|  11.7k|            using m_t = decltype( m );
   48|  24.4k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.22k, False: 21]
  |  Branch (48:25): [True: 3.53k, False: 688]
  |  Branch (48:25): [True: 4.24k, False: 7.49k]
  ------------------
   49|  11.7k|         }
   50|  11.7k|      }
_ZN3tao5pegtl8internal3seqIJNS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEENS8_3oneIJLc123EEEENS0_4starIS9_JEEENS0_4listINS5_12string_valueESA_vEESF_NSC_IJLc125EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSU_11char_traitsIcEENSU_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   41|  4.22k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.22k|         else {
   46|  4.22k|            auto m = in.template mark< M >();
   47|  4.22k|            using m_t = decltype( m );
   48|  29.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.38k, False: 0]
  |  Branch (48:25): [True: 2.25k, False: 127]
  |  Branch (48:25): [True: 2.38k, False: 82]
  |  Branch (48:25): [True: 2.46k, False: 0]
  |  Branch (48:25): [True: 2.46k, False: 1.75k]
  |  Branch (48:25): [True: 4.22k, False: 0]
  ------------------
   49|  4.22k|         }
   50|  4.22k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  4.22k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.22k|         else {
   46|  4.22k|            auto m = in.template mark< M >();
   47|  4.22k|            using m_t = decltype( m );
   48|  5.84k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.62k, False: 2.59k]
  |  Branch (48:25): [True: 1.56k, False: 56]
  ------------------
   49|  4.22k|         }
   50|  4.22k|      }
_ZN3tao5pegtl8internal3seqIJN8usbguard10RuleParser12string_valueENS1_4starINS0_4plusINS0_5ascii5blankEJEEEJS5_EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   41|  2.46k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.46k|         else {
   46|  2.46k|            auto m = in.template mark< M >();
   47|  2.46k|            using m_t = decltype( m );
   48|  4.87k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.40k, False: 66]
  |  Branch (48:25): [True: 2.38k, False: 16]
  ------------------
   49|  2.46k|         }
   50|  2.46k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  4.51k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.51k|         else {
   46|  4.51k|            auto m = in.template mark< M >();
   47|  4.51k|            using m_t = decltype( m );
   48|  7.13k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.61k, False: 1.89k]
  |  Branch (48:25): [True: 2.11k, False: 503]
  ------------------
   49|  4.51k|         }
   50|  4.51k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15rule_attributesEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|  29.3k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  29.3k|         else {
   46|  29.3k|            auto m = in.template mark< M >();
   47|  29.3k|            using m_t = decltype( m );
   48|  34.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.74k, False: 24.5k]
  |  Branch (48:25): [True: 3.06k, False: 1.68k]
  ------------------
   49|  29.3k|         }
   50|  29.3k|      }

_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  38.4k|      {
   58|  38.4k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  38.4k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSI_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  38.4k|      {
   45|  76.8k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 26, False: 38.4k]
  |  Branch (45:19): [True: 38.2k, False: 104]
  ------------------
   46|  38.4k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser9str_allowENS4_9str_blockENS4_10str_rejectENS4_9str_matchENS4_10str_deviceEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  38.4k|      {
   58|  38.4k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  38.4k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser9str_allowENS4_9str_blockENS4_10str_rejectENS4_9str_matchENS4_10str_deviceEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  38.4k|      {
   45|  50.5k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 925, False: 152]
  |  Branch (45:19): [True: 48, False: 104]
  |  Branch (45:19): [True: 14, False: 1.07k]
  |  Branch (45:19): [True: 2.71k, False: 1.09k]
  |  Branch (45:19): [True: 34.5k, False: 3.80k]
  ------------------
   46|  38.4k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  40.0k|      {
   58|  40.0k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  40.0k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  40.0k|      {
   45|  78.1k|         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: 38.1k]
  |  Branch (45:19): [True: 1.63k, False: 36.4k]
  ------------------
   46|  40.0k|      }
_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_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  41.8k|      {
   58|  41.8k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  41.8k|      }
_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_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSQ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  41.8k|      {
   45|   488k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 5.18k, False: 11.7k]
  |  Branch (45:19): [True: 3.88k, False: 7.85k]
  |  Branch (45:19): [True: 2.53k, False: 16.9k]
  |  Branch (45:19): [True: 2.92k, False: 19.4k]
  |  Branch (45:19): [True: 3.11k, False: 22.3k]
  |  Branch (45:19): [True: 2.65k, False: 25.4k]
  |  Branch (45:19): [True: 3.21k, False: 28.1k]
  |  Branch (45:19): [True: 3.76k, False: 31.3k]
  |  Branch (45:19): [True: 3.28k, False: 35.1k]
  |  Branch (45:19): [True: 3.40k, False: 38.4k]
  ------------------
   46|  41.8k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.85k|      {
   58|  3.85k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.85k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.85k|      {
   45|  5.36k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.35k, False: 1.50k]
  |  Branch (45:19): [True: 1.03k, False: 466]
  ------------------
   46|  3.85k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.85k|      {
   58|  3.85k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.85k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.85k|      {
   45|  31.5k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 437, False: 2.08k]
  |  Branch (45:19): [True: 202, False: 1.88k]
  |  Branch (45:19): [True: 688, False: 2.52k]
  |  Branch (45:19): [True: 215, False: 3.20k]
  |  Branch (45:19): [True: 212, False: 3.42k]
  |  Branch (45:19): [True: 223, False: 3.63k]
  ------------------
   46|  3.85k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  1.91M|      {
   58|  1.91M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  1.91M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  1.91M|      {
   45|  3.82M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.35k, False: 1.90M]
  |  Branch (45:19): [True: 1.90M, False: 1.94k]
  ------------------
   46|  1.91M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.60k|      {
   58|  3.60k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.60k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.60k|      {
   45|  4.91k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.29k, False: 1.31k]
  |  Branch (45:19): [True: 982, False: 330]
  ------------------
   46|  3.60k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.60k|      {
   58|  3.60k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.60k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.60k|      {
   45|  29.0k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 229, False: 2.27k]
  |  Branch (45:19): [True: 197, False: 2.07k]
  |  Branch (45:19): [True: 195, False: 2.50k]
  |  Branch (45:19): [True: 285, False: 2.69k]
  |  Branch (45:19): [True: 422, False: 2.98k]
  |  Branch (45:19): [True: 202, False: 3.40k]
  ------------------
   46|  3.60k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  16.7M|      {
   58|  16.7M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  16.7M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  16.7M|      {
   45|  33.2M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 264k, False: 16.4M]
  |  Branch (45:19): [True: 16.4M, False: 208]
  ------------------
   46|  16.7M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   264k|      {
   58|   264k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   264k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   264k|      {
   45|   775k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 102k, False: 4.62k]
  |  Branch (45:19): [True: 4.56k, False: 56]
  |  Branch (45:19): [True: 39.4k, False: 106k]
  |  Branch (45:19): [True: 117k, False: 146k]
  ------------------
   46|   264k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.10k|      {
   58|  4.10k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.10k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.10k|      {
   45|  5.64k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.57k, False: 1.53k]
  |  Branch (45:19): [True: 1.19k, False: 345]
  ------------------
   46|  4.10k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.10k|      {
   58|  4.10k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.10k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.10k|      {
   45|  35.2k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 329, False: 2.88k]
  |  Branch (45:19): [True: 219, False: 2.66k]
  |  Branch (45:19): [True: 194, False: 3.21k]
  |  Branch (45:19): [True: 207, False: 3.40k]
  |  Branch (45:19): [True: 284, False: 3.61k]
  |  Branch (45:19): [True: 212, False: 3.89k]
  ------------------
   46|  4.10k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  9.86M|      {
   58|  9.86M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  9.86M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  9.86M|      {
   45|  19.5M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 143k, False: 9.71M]
  |  Branch (45:19): [True: 9.71M, False: 210]
  ------------------
   46|  9.86M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   143k|      {
   58|   143k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   143k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   143k|      {
   45|   430k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 46.5k, False: 897]
  |  Branch (45:19): [True: 836, False: 61]
  |  Branch (45:19): [True: 48.0k, False: 47.4k]
  |  Branch (45:19): [True: 48.1k, False: 95.4k]
  ------------------
   46|   143k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.53k|      {
   58|  3.53k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.53k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.53k|      {
   45|  4.89k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.17k, False: 1.36k]
  |  Branch (45:19): [True: 1.03k, False: 329]
  ------------------
   46|  3.53k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.53k|      {
   58|  3.53k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.53k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.53k|      {
   45|  29.6k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 257, False: 2.34k]
  |  Branch (45:19): [True: 202, False: 2.14k]
  |  Branch (45:19): [True: 277, False: 2.60k]
  |  Branch (45:19): [True: 197, False: 2.88k]
  |  Branch (45:19): [True: 255, False: 3.07k]
  |  Branch (45:19): [True: 205, False: 3.33k]
  ------------------
   46|  3.53k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  7.78M|      {
   58|  7.78M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  7.78M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  7.78M|      {
   45|  15.4M|         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.62M]
  |  Branch (45:19): [True: 7.62M, False: 167]
  ------------------
   46|  7.78M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_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_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   156k|      {
   45|   447k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 57.3k, False: 2.15k]
  |  Branch (45:19): [True: 2.10k, False: 55]
  |  Branch (45:19): [True: 25.2k, False: 59.5k]
  |  Branch (45:19): [True: 71.9k, False: 84.7k]
  ------------------
   46|   156k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  2.89k|      {
   58|  2.89k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.89k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  2.89k|      {
   45|  4.09k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.69k, False: 1.20k]
  |  Branch (45:19): [True: 961, False: 240]
  ------------------
   46|  2.89k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  2.89k|      {
   58|  2.89k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.89k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  2.89k|      {
   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: 332, False: 1.85k]
  |  Branch (45:19): [True: 465, False: 1.39k]
  |  Branch (45:19): [True: 66, False: 2.19k]
  |  Branch (45:19): [True: 195, False: 2.25k]
  |  Branch (45:19): [True: 224, False: 2.45k]
  |  Branch (45:19): [True: 216, False: 2.67k]
  ------------------
   46|  2.89k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  2.50M|      {
   58|  2.50M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.50M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  2.50M|      {
   45|  5.00M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 8.81k, False: 2.49M]
  |  Branch (45:19): [True: 2.49M, False: 164]
  ------------------
   46|  2.50M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  8.81k|      {
   58|  8.81k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  8.81k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  8.81k|      {
   45|  28.5k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.11k, False: 219]
  |  Branch (45:19): [True: 196, False: 23]
  |  Branch (45:19): [True: 3.07k, False: 3.33k]
  |  Branch (45:19): [True: 2.40k, False: 6.41k]
  ------------------
   46|  8.81k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.43k|      {
   58|  3.43k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.43k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.43k|      {
   45|  4.84k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.02k, False: 1.41k]
  |  Branch (45:19): [True: 1.08k, False: 325]
  ------------------
   46|  3.43k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.43k|      {
   58|  3.43k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.43k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.43k|      {
   45|  29.1k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 272, False: 2.34k]
  |  Branch (45:19): [True: 212, False: 2.13k]
  |  Branch (45:19): [True: 195, False: 2.61k]
  |  Branch (45:19): [True: 194, False: 2.81k]
  |  Branch (45:19): [True: 218, False: 3.00k]
  |  Branch (45:19): [True: 210, False: 3.22k]
  ------------------
   46|  3.43k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  6.18M|      {
   58|  6.18M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.18M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  6.18M|      {
   45|  12.3M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 61.8k, False: 6.12M]
  |  Branch (45:19): [True: 6.12M, False: 200]
  ------------------
   46|  6.18M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  61.8k|      {
   58|  61.8k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  61.8k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  61.8k|      {
   45|   173k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 20.4k, False: 407]
  |  Branch (45:19): [True: 347, False: 60]
  |  Branch (45:19): [True: 13.9k, False: 20.8k]
  |  Branch (45:19): [True: 27.0k, False: 34.7k]
  ------------------
   46|  61.8k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.38k|      {
   58|  3.38k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.38k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.38k|      {
   45|  4.54k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.21k, False: 1.16k]
  |  Branch (45:19): [True: 705, False: 456]
  ------------------
   46|  3.38k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  3.38k|      {
   58|  3.38k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.38k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  3.38k|      {
   45|  27.1k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 496, False: 1.77k]
  |  Branch (45:19): [True: 307, False: 1.47k]
  |  Branch (45:19): [True: 333, False: 2.27k]
  |  Branch (45:19): [True: 332, False: 2.60k]
  |  Branch (45:19): [True: 209, False: 2.94k]
  |  Branch (45:19): [True: 231, False: 3.14k]
  ------------------
   46|  3.38k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex2ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   331k|      {
   58|   331k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   331k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex2ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   331k|      {
   45|   491k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 171k, False: 159k]
  |  Branch (45:19): [True: 159k, False: 54]
  ------------------
   46|   331k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  2.82k|      {
   58|  2.82k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.82k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  2.82k|      {
   45|  3.69k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.96k, False: 869]
  |  Branch (45:19): [True: 572, False: 297]
  ------------------
   46|  2.82k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  2.82k|      {
   58|  2.82k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.82k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  2.82k|      {
   45|  22.7k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 274, False: 1.67k]
  |  Branch (45:19): [True: 194, False: 1.47k]
  |  Branch (45:19): [True: 227, False: 1.94k]
  |  Branch (45:19): [True: 226, False: 2.17k]
  |  Branch (45:19): [True: 224, False: 2.40k]
  |  Branch (45:19): [True: 205, False: 2.62k]
  ------------------
   46|  2.82k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_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_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_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: 92.0k, False: 7.24M]
  |  Branch (45:19): [True: 7.24M, False: 176]
  ------------------
   46|  7.34M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  92.0k|      {
   58|  92.0k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  92.0k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  92.0k|      {
   45|   316k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 39.8k, False: 1.02k]
  |  Branch (45:19): [True: 994, False: 34]
  |  Branch (45:19): [True: 29.8k, False: 40.8k]
  |  Branch (45:19): [True: 21.2k, False: 70.7k]
  ------------------
   46|  92.0k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  5.90k|      {
   58|  5.90k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  5.90k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  5.90k|      {
   45|  8.73k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.07k, False: 2.82k]
  |  Branch (45:19): [True: 2.10k, False: 723]
  ------------------
   46|  5.90k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  5.90k|      {
   58|  5.90k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  5.90k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  5.90k|      {
   45|  54.5k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 275, False: 4.81k]
  |  Branch (45:19): [True: 203, False: 4.61k]
  |  Branch (45:19): [True: 296, False: 5.09k]
  |  Branch (45:19): [True: 224, False: 5.39k]
  |  Branch (45:19): [True: 215, False: 5.61k]
  |  Branch (45:19): [True: 76, False: 5.82k]
  ------------------
   46|  5.90k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc41EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  44.7M|      {
   58|  44.7M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  44.7M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc41EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  44.7M|      {
   45|  89.3M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 174k, False: 44.5M]
  |  Branch (45:19): [True: 44.5M, False: 255]
  ------------------
   46|  44.7M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   174k|      {
   58|   174k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   174k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   174k|      {
   45|   698k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 115k, False: 593]
  |  Branch (45:19): [True: 531, False: 62]
  |  Branch (45:19): [True: 29.1k, False: 116k]
  |  Branch (45:19): [True: 29.0k, False: 145k]
  ------------------
   46|   174k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.22k|      {
   58|  4.22k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.22k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.22k|      {
   45|  6.14k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.29k, False: 1.92k]
  |  Branch (45:19): [True: 1.58k, False: 336]
  ------------------
   46|  4.22k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  4.22k|      {
   58|  4.22k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.22k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser10str_all_ofENS4_10str_one_ofENS4_11str_none_ofENS4_18str_equals_orderedENS4_10str_equalsENS4_13str_match_allEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSM_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  4.22k|      {
   45|  35.8k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 427, False: 2.84k]
  |  Branch (45:19): [True: 250, False: 2.59k]
  |  Branch (45:19): [True: 198, False: 3.27k]
  |  Branch (45:19): [True: 224, False: 3.47k]
  |  Branch (45:19): [True: 252, False: 3.69k]
  |  Branch (45:19): [True: 273, False: 3.94k]
  ------------------
   46|  4.22k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  10.6M|      {
   58|  10.6M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  10.6M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  10.6M|      {
   45|  21.0M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 110k, False: 10.4M]
  |  Branch (45:19): [True: 10.4M, False: 200]
  ------------------
   46|  10.6M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   110k|      {
   58|   110k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   110k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3EENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSL_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|   110k|      {
   45|   313k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 31.0k, False: 1.69k]
  |  Branch (45:19): [True: 1.63k, False: 60]
  |  Branch (45:19): [True: 35.3k, False: 32.7k]
  |  Branch (45:19): [True: 42.1k, False: 68.1k]
  ------------------
   46|   110k|      }

_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|   144k|      {
   41|   163k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 19.0k, False: 144k]
  ------------------
   42|  19.0k|         }
   43|   144k|         return true;
   44|   144k|      }
_ZN3tao5pegtl8internal4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSE_4RuleEEEEbRT3_DpOT4_:
   40|  10.3k|      {
   41|   523k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 513k, False: 10.3k]
  ------------------
   42|   513k|         }
   43|  10.3k|         return true;
   44|  10.3k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  5.10k|      {
   41|  9.07k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.97k, False: 5.10k]
  ------------------
   42|  3.97k|         }
   43|  5.10k|         return true;
   44|  5.10k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15device_id_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.51k|      {
   41|   953k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 951k, False: 2.51k]
  ------------------
   42|   951k|         }
   43|  2.51k|         return true;
   44|  2.51k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.86k|      {
   41|  6.70k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.84k, False: 4.86k]
  ------------------
   42|  1.84k|         }
   43|  4.86k|         return true;
   44|  4.86k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.41k|      {
   41|   310k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 308k, False: 2.41k]
  ------------------
   42|   308k|         }
   43|  2.41k|         return true;
   44|  2.41k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  5.39k|      {
   41|  8.67k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.27k, False: 5.39k]
  ------------------
   42|  3.27k|         }
   43|  5.39k|         return true;
   44|  5.39k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.67k|      {
   41|  6.27k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.59k, False: 2.67k]
  ------------------
   42|  3.59k|         }
   43|  2.67k|         return true;
   44|  2.67k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.64k|      {
   41|  7.14k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.50k, False: 4.64k]
  ------------------
   42|  2.50k|         }
   43|  4.64k|         return true;
   44|  4.64k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.30k|      {
   41|  5.81k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.50k, False: 2.30k]
  ------------------
   42|  3.50k|         }
   43|  2.30k|         return true;
   44|  2.30k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  3.58k|      {
   41|  5.62k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.03k, False: 3.58k]
  ------------------
   42|  2.03k|         }
   43|  3.58k|         return true;
   44|  3.58k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  1.77k|      {
   41|  3.71k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.94k, False: 1.77k]
  ------------------
   42|  1.94k|         }
   43|  1.77k|         return true;
   44|  1.77k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.32k|      {
   41|  7.00k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.67k, False: 4.32k]
  ------------------
   42|  2.67k|         }
   43|  4.32k|         return true;
   44|  4.32k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.13k|      {
   41|  4.70k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.56k, False: 2.13k]
  ------------------
   42|  2.56k|         }
   43|  2.13k|         return true;
   44|  2.13k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.85k|      {
   41|  8.68k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.82k, False: 4.85k]
  ------------------
   42|  3.82k|         }
   43|  4.85k|         return true;
   44|  4.85k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15interface_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.40k|      {
   41|   165k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 162k, False: 2.40k]
  ------------------
   42|   162k|         }
   43|  2.40k|         return true;
   44|  2.40k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.16k|      {
   41|  6.72k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.55k, False: 4.16k]
  ------------------
   42|  2.55k|         }
   43|  4.16k|         return true;
   44|  4.16k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.05k|      {
   41|  4.55k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.50k, False: 2.05k]
  ------------------
   42|  2.50k|         }
   43|  2.05k|         return true;
   44|  2.05k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  6.21k|      {
   41|  8.24k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.03k, False: 6.21k]
  ------------------
   42|  2.03k|         }
   43|  6.21k|         return true;
   44|  6.21k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  3.59k|      {
   41|   637k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 633k, False: 3.59k]
  ------------------
   42|   633k|         }
   43|  3.59k|         return true;
   44|  3.59k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   40|   640k|      {
   41|  29.4M|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 28.8M, False: 640k]
  ------------------
   42|  28.8M|         }
   43|   640k|         return true;
   44|   640k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.85k|      {
   41|  6.48k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.63k, False: 4.85k]
  ------------------
   42|  1.63k|         }
   43|  4.85k|         return true;
   44|  4.85k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  2.40k|      {
   41|  4.51k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.11k, False: 2.40k]
  ------------------
   42|  2.11k|         }
   43|  2.40k|         return true;
   44|  2.40k|      }
_ZN3tao5pegtl8internal4starINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15rule_attributesEEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   40|  26.2k|      {
   41|  29.3k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.06k, False: 26.2k]
  ------------------
   42|  3.06k|         }
   43|  26.2k|         return true;
   44|  26.2k|      }

_ZN3tao5pegtl8internal13unsafe_equalsEPKcRKSt16initializer_listIcE:
   23|   417k|   {
   24|   417k|      return std::memcmp( s, &*l.begin(), l.size() ) == 0;
   25|   417k|   }
_ZN3tao5pegtl8internal6stringIJLc97ELc108ELc108ELc111ELc119EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  38.4k|      {
   52|  38.4k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 38.3k, False: 44]
  ------------------
   53|  38.3k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 34.5k, False: 3.76k]
  ------------------
   54|  34.5k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  34.5k|               return true;
   56|  34.5k|            }
   57|  38.3k|         }
   58|  3.80k|         return false;
   59|  38.4k|      }
_ZN3tao5pegtl8internal6stringIJLc98ELc108ELc111ELc99ELc107EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  3.80k|      {
   52|  3.80k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 3.76k, False: 44]
  ------------------
   53|  3.76k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.71k, False: 1.04k]
  ------------------
   54|  2.71k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.71k|               return true;
   56|  2.71k|            }
   57|  3.76k|         }
   58|  1.09k|         return false;
   59|  3.80k|      }
_ZN3tao5pegtl8internal6stringIJLc114ELc101ELc106ELc101ELc99ELc116EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  1.09k|      {
   52|  1.09k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 1.00k, False: 82]
  ------------------
   53|  1.00k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 14, False: 995]
  ------------------
   54|     14|               bump_help< string >( in, sizeof...( Cs ) );
   55|     14|               return true;
   56|     14|            }
   57|  1.00k|         }
   58|  1.07k|         return false;
   59|  1.09k|      }
_ZN3tao5pegtl8internal6stringIJLc109ELc97ELc116ELc99ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  1.07k|      {
   52|  1.07k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 1.03k, False: 44]
  ------------------
   53|  1.03k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 925, False: 108]
  ------------------
   54|    925|               bump_help< string >( in, sizeof...( Cs ) );
   55|    925|               return true;
   56|    925|            }
   57|  1.03k|         }
   58|    152|         return false;
   59|  1.07k|      }
_ZN3tao5pegtl8internal6stringIJLc100ELc101ELc118ELc105ELc99ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|    152|      {
   52|    152|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 71, False: 81]
  ------------------
   53|     71|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 48, False: 23]
  ------------------
   54|     48|               bump_help< string >( in, sizeof...( Cs ) );
   55|     48|               return true;
   56|     48|            }
   57|     71|         }
   58|    104|         return false;
   59|    152|      }
_ZN3tao5pegtl8internal6stringIJLc105ELc100EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  41.8k|      {
   52|  41.8k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 39.8k, False: 1.99k]
  ------------------
   53|  39.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.88k, False: 35.9k]
  ------------------
   54|  3.88k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.88k|               return true;
   56|  3.88k|            }
   57|  39.8k|         }
   58|  37.9k|         return false;
   59|  41.8k|      }
_ZN3tao5pegtl8internal6stringIJLc97ELc108ELc108ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  37.7k|      {
   52|  37.7k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 30.8k, False: 6.92k]
  ------------------
   53|  30.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.05k, False: 28.7k]
  ------------------
   54|  2.05k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.05k|               return true;
   56|  2.05k|            }
   57|  30.8k|         }
   58|  35.7k|         return false;
   59|  37.7k|      }
_ZN3tao5pegtl8internal6stringIJLc111ELc110ELc101ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  35.7k|      {
   52|  35.7k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 28.7k, False: 6.92k]
  ------------------
   53|  28.7k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.51k, False: 26.2k]
  ------------------
   54|  2.51k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.51k|               return true;
   56|  2.51k|            }
   57|  28.7k|         }
   58|  33.2k|         return false;
   59|  35.7k|      }
_ZN3tao5pegtl8internal6stringIJLc110ELc111ELc110ELc101ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  33.2k|      {
   52|  33.2k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 24.9k, False: 8.22k]
  ------------------
   53|  24.9k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.29k, False: 22.6k]
  ------------------
   54|  2.29k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.29k|               return true;
   56|  2.29k|            }
   57|  24.9k|         }
   58|  30.9k|         return false;
   59|  33.2k|      }
_ZN3tao5pegtl8internal6stringIJLc101ELc113ELc117ELc97ELc108ELc115ELc45ELc111ELc114ELc100ELc101ELc114ELc101ELc100EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  30.9k|      {
   52|  30.9k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 16.8k, False: 14.0k]
  ------------------
   53|  16.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.66k, False: 14.1k]
  ------------------
   54|  2.66k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.66k|               return true;
   56|  2.66k|            }
   57|  16.8k|         }
   58|  28.2k|         return false;
   59|  30.9k|      }
_ZN3tao5pegtl8internal6stringIJLc101ELc113ELc117ELc97ELc108ELc115EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  28.2k|      {
   52|  28.2k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 21.3k, False: 6.92k]
  ------------------
   53|  21.3k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.32k, False: 17.9k]
  ------------------
   54|  3.32k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.32k|               return true;
   56|  3.32k|            }
   57|  21.3k|         }
   58|  24.9k|         return false;
   59|  28.2k|      }
_ZN3tao5pegtl8internal6stringIJLc109ELc97ELc116ELc99ELc104ELc45ELc97ELc108ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  24.9k|      {
   52|  24.9k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 15.1k, False: 9.73k]
  ------------------
   53|  15.1k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.45k, False: 12.7k]
  ------------------
   54|  2.45k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.45k|               return true;
   56|  2.45k|            }
   57|  15.1k|         }
   58|  22.4k|         return false;
   59|  24.9k|      }
_ZN3tao5pegtl8internal6stringIJLc110ELc97ELc109ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  38.4k|      {
   52|  38.4k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 36.1k, False: 2.26k]
  ------------------
   53|  36.1k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.62k, False: 32.5k]
  ------------------
   54|  3.62k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.62k|               return true;
   56|  3.62k|            }
   57|  36.1k|         }
   58|  34.7k|         return false;
   59|  38.4k|      }
_ZN3tao5pegtl8internal6stringIJLc104ELc97ELc115ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  35.1k|      {
   52|  35.1k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 32.8k, False: 2.26k]
  ------------------
   53|  32.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.13k, False: 28.7k]
  ------------------
   54|  4.13k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.13k|               return true;
   56|  4.13k|            }
   57|  32.8k|         }
   58|  30.9k|         return false;
   59|  35.1k|      }
_ZN3tao5pegtl8internal6stringIJLc112ELc97ELc114ELc101ELc110ELc116ELc45ELc104ELc97ELc115ELc104EEE5matchINS0_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: 25.6k, False: 5.68k]
  ------------------
   53|  25.6k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.55k, False: 22.1k]
  ------------------
   54|  3.55k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.55k|               return true;
   56|  3.55k|            }
   57|  25.6k|         }
   58|  27.8k|         return false;
   59|  31.3k|      }
_ZN3tao5pegtl8internal6stringIJLc115ELc101ELc114ELc105ELc97ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  28.1k|      {
   52|  28.1k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 25.4k, False: 2.67k]
  ------------------
   53|  25.4k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.90k, False: 22.5k]
  ------------------
   54|  2.90k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.90k|               return true;
   56|  2.90k|            }
   57|  25.4k|         }
   58|  25.2k|         return false;
   59|  28.1k|      }
_ZN3tao5pegtl8internal6stringIJLc118ELc105ELc97ELc45ELc112ELc111ELc114ELc116EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  25.4k|      {
   52|  25.4k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 21.8k, False: 3.62k]
  ------------------
   53|  21.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.45k, False: 18.4k]
  ------------------
   54|  3.45k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.45k|               return true;
   56|  3.45k|            }
   57|  21.8k|         }
   58|  22.0k|         return false;
   59|  25.4k|      }
_ZN3tao5pegtl8internal6stringIJLc119ELc105ELc116ELc104ELc45ELc105ELc110ELc116ELc101ELc114ELc102ELc97ELc99ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  22.3k|      {
   52|  22.3k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 16.3k, False: 6.02k]
  ------------------
   53|  16.3k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.38k, False: 12.9k]
  ------------------
   54|  3.38k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.38k|               return true;
   56|  3.38k|            }
   57|  16.3k|         }
   58|  18.9k|         return false;
   59|  22.3k|      }
_ZN3tao5pegtl8internal6stringIJLc119ELc105ELc116ELc104ELc45ELc99ELc111ELc110ELc110ELc101ELc99ELc116ELc45ELc116ELc121ELc112ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  19.4k|      {
   52|  19.4k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 12.6k, False: 6.83k]
  ------------------
   53|  12.6k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.84k, False: 9.78k]
  ------------------
   54|  2.84k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.84k|               return true;
   56|  2.84k|            }
   57|  12.6k|         }
   58|  16.6k|         return false;
   59|  19.4k|      }
_ZN3tao5pegtl8internal6stringIJLc105ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  16.9k|      {
   52|  16.9k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 14.9k, False: 1.99k]
  ------------------
   53|  14.9k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 5.93k, False: 8.99k]
  ------------------
   54|  5.93k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  5.93k|               return true;
   56|  5.93k|            }
   57|  14.9k|         }
   58|  10.9k|         return false;
   59|  16.9k|      }
_ZN3tao5pegtl8internal6stringIJLc108ELc97ELc98ELc101ELc108EEE5matchINS0_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: 9.32k, False: 2.41k]
  ------------------
   53|  9.32k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.24k, False: 5.08k]
  ------------------
   54|  4.24k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.24k|               return true;
   56|  4.24k|            }
   57|  9.32k|         }
   58|  7.49k|         return false;
   59|  11.7k|      }

_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|   311k|      {
   71|   311k|         auto m = in.template mark< M >();
   72|   311k|         using m_t = decltype( m );
   73|       |
   74|  17.0M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 16.7M, False: 311k]
  ------------------
   75|  16.7M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 208, False: 16.7M]
  ------------------
   76|    208|               return false;
   77|    208|            }
   78|  16.7M|         }
   79|   311k|         return m( true );
   80|   311k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  7.50k|      {
   71|  7.50k|         auto m = in.template mark< M >();
   72|  7.50k|         using m_t = decltype( m );
   73|       |
   74|  9.87M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 9.86M, False: 7.29k]
  ------------------
   75|  9.86M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 210, False: 9.86M]
  ------------------
   76|    210|               return false;
   77|    210|            }
   78|  9.86M|         }
   79|  7.29k|         return m( true );
   80|  7.50k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  6.87k|      {
   71|  6.87k|         auto m = in.template mark< M >();
   72|  6.87k|         using m_t = decltype( m );
   73|       |
   74|  7.78M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 7.78M, False: 6.70k]
  ------------------
   75|  7.78M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 167, False: 7.78M]
  ------------------
   76|    167|               return false;
   77|    167|            }
   78|  7.78M|         }
   79|  6.70k|         return m( true );
   80|  6.87k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  4.69k|      {
   71|  4.69k|         auto m = in.template mark< M >();
   72|  4.69k|         using m_t = decltype( m );
   73|       |
   74|  2.50M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 2.50M, False: 4.53k]
  ------------------
   75|  2.50M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 164, False: 2.50M]
  ------------------
   76|    164|               return false;
   77|    164|            }
   78|  2.50M|         }
   79|  4.53k|         return m( true );
   80|  4.69k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  5.81k|      {
   71|  5.81k|         auto m = in.template mark< M >();
   72|  5.81k|         using m_t = decltype( m );
   73|       |
   74|  6.19M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 6.18M, False: 5.61k]
  ------------------
   75|  6.18M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 200, False: 6.18M]
  ------------------
   76|    200|               return false;
   77|    200|            }
   78|  6.18M|         }
   79|  5.61k|         return m( true );
   80|  5.81k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  5.16k|      {
   71|  5.16k|         auto m = in.template mark< M >();
   72|  5.16k|         using m_t = decltype( m );
   73|       |
   74|  7.34M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 7.34M, False: 4.99k]
  ------------------
   75|  7.34M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 176, False: 7.34M]
  ------------------
   76|    176|               return false;
   77|    176|            }
   78|  7.34M|         }
   79|  4.99k|         return m( true );
   80|  5.16k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  35.4k|      {
   71|  35.4k|         auto m = in.template mark< M >();
   72|  35.4k|         using m_t = decltype( m );
   73|       |
   74|  44.7M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 44.7M, False: 35.2k]
  ------------------
   75|  44.7M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 255, False: 44.7M]
  ------------------
   76|    255|               return false;
   77|    255|            }
   78|  44.7M|         }
   79|  35.2k|         return m( true );
   80|  35.4k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  6.14k|      {
   71|  6.14k|         auto m = in.template mark< M >();
   72|  6.14k|         using m_t = decltype( m );
   73|       |
   74|  10.6M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 10.6M, False: 5.94k]
  ------------------
   75|  10.6M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 200, False: 10.6M]
  ------------------
   76|    200|               return false;
   77|    200|            }
   78|  10.6M|         }
   79|  5.94k|         return m( true );
   80|  6.14k|      }

_ZN3tao5pegtl5matchIN8usbguard10RuleParser12rule_grammarELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.4k|      else {
  108|  38.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.2k, False: 9.18k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.2k|            else if constexpr( has_apply0_bool ) {
  153|  29.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.2k|            }
  155|  29.2k|         }
  156|  38.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.2k, False: 9.18k]
  ------------------
  157|  29.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.2k|         }
  159|  9.18k|         else {
  160|  9.18k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.18k|         }
  162|  38.4k|         (void)m( result );
  163|  38.4k|         return result;
  164|  38.4k|      }
  165|  38.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12rule_grammarELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.4k|      {
   73|  38.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.4k|         else {
   84|  38.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12rule_grammarELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.4k|      {
   44|  38.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.4k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   144k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   144k|      else {
  108|   144k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   144k|         using iterator_t = typename ParseInput::iterator_t;
  111|   144k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   144k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   144k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   144k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   144k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   144k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   144k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   144k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   144k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   144k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   144k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   144k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   144k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   144k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   144k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   144k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   144k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   144k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 144k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   144k|            else if constexpr( has_apply0_bool ) {
  153|   144k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   144k|            }
  155|   144k|         }
  156|   144k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 144k, False: 0]
  ------------------
  157|   144k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   144k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   144k|         (void)m( result );
  163|   144k|         return result;
  164|   144k|      }
  165|   144k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|   144k|      {
   73|   144k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   144k|         else {
   84|   144k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   144k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   144k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   144k|      {
   44|   144k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   144k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   248k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   248k|      else {
  108|   248k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   248k|         using iterator_t = typename ParseInput::iterator_t;
  111|   248k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   248k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   248k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   248k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   248k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   248k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   248k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   248k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   248k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   248k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   248k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   248k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   248k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   248k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   248k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   248k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   248k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   248k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 24.2k, False: 224k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  24.2k|            else if constexpr( has_apply0_bool ) {
  153|  24.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  24.2k|            }
  155|  24.2k|         }
  156|   248k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 24.2k, False: 224k]
  ------------------
  157|  24.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  24.2k|         }
  159|   224k|         else {
  160|   224k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   224k|         }
  162|   248k|         (void)m( result );
  163|   248k|         return result;
  164|   248k|      }
  165|   248k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   248k|      {
   73|   248k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   248k|         else {
   84|   248k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   248k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   248k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   248k|      {
   59|   248k|         return Rule::match( in );
   60|   248k|      }
_ZN3tao5pegtl5matchINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  38.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.4k|      else {
  108|  38.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.8k, False: 4.62k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  33.8k|            else if constexpr( has_apply0_bool ) {
  153|  33.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.8k|            }
  155|  33.8k|         }
  156|  38.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.8k, False: 4.62k]
  ------------------
  157|  33.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.8k|         }
  159|  4.62k|         else {
  160|  4.62k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.62k|         }
  162|  38.4k|         (void)m( result );
  163|  38.4k|         return result;
  164|  38.4k|      }
  165|  38.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS6_4ruleEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS6_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
   72|  38.4k|      {
   73|  38.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.4k|         else {
   84|  38.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS6_4ruleEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS6_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.4k|      {
   44|  38.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.4k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  38.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.4k|      else {
  108|  38.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.6k, False: 4.73k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  33.6k|            else if constexpr( has_apply0_bool ) {
  153|  33.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.6k|            }
  155|  33.6k|         }
  156|  38.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.6k, False: 4.73k]
  ------------------
  157|  33.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.6k|         }
  159|  4.73k|         else {
  160|  4.73k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.73k|         }
  162|  38.4k|         (void)m( result );
  163|  38.4k|         return result;
  164|  38.4k|      }
  165|  38.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  38.4k|      {
   73|  38.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.4k|         else {
   84|  38.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.4k|      {
   44|  38.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser7commentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  72.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  72.1k|      else {
  108|  72.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  72.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  72.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  72.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  72.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  72.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [True: 0, Folded]
  ------------------
  116|  72.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  72.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [True: 72.1k, Folded]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  72.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  72.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  72.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  72.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  72.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  72.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  72.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|  72.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  72.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  72.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  72.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  72.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.3k, False: 61.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|  10.3k|            else if constexpr( has_apply0_void ) {
  150|  10.3k|               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  10.3k|         }
  156|  72.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.3k, False: 61.7k]
  ------------------
  157|  10.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.3k|         }
  159|  61.7k|         else {
  160|  61.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  61.7k|         }
  162|  72.1k|         (void)m( result );
  163|  72.1k|         return result;
  164|  72.1k|      }
  165|  72.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser7commentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  72.1k|      {
   73|  72.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  72.1k|         else {
   84|  72.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  72.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  72.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser7commentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  72.1k|      {
   44|  72.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  72.1k|      }
_ZN3tao5pegtl5matchINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNSH_4RuleEEEEDaRT4_DpOT5_:
  103|  72.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  72.1k|      else {
  108|  72.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  72.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  72.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  72.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  72.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  72.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  72.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  72.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  72.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  72.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  72.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  72.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  72.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  72.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  72.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|  72.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  72.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  72.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  72.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  72.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.3k, False: 61.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  10.3k|            else if constexpr( has_apply0_bool ) {
  153|  10.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.3k|            }
  155|  10.3k|         }
  156|  72.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.3k, False: 61.7k]
  ------------------
  157|  10.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.3k|         }
  159|  61.7k|         else {
  160|  61.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  61.7k|         }
  162|  72.1k|         (void)m( result );
  163|  72.1k|         return result;
  164|  72.1k|      }
  165|  72.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS4_3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNSI_4RuleEEEEDaRT4_DpOT5_:
   72|  72.1k|      {
   73|  72.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  72.1k|         else {
   84|  72.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  72.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  72.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS4_3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNSI_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  72.1k|      {
   44|  72.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  72.1k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc35EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  72.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  72.1k|      else {
  108|  72.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  72.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  72.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  72.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  72.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  72.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  72.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  72.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  72.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  72.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  72.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  72.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  72.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  72.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  72.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|  72.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  72.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  72.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  72.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  72.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.3k, False: 61.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  10.3k|            else if constexpr( has_apply0_bool ) {
  153|  10.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.3k|            }
  155|  10.3k|         }
  156|  72.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.3k, False: 61.7k]
  ------------------
  157|  10.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.3k|         }
  159|  61.7k|         else {
  160|  61.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  61.7k|         }
  162|  72.1k|         (void)m( result );
  163|  72.1k|         return result;
  164|  72.1k|      }
  165|  72.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc35EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  72.1k|      {
   73|  72.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  72.1k|         else {
   84|  72.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  72.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  72.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc35EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  72.1k|      {
   59|  72.1k|         return Rule::match( in );
   60|  72.1k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNSG_4RuleEEEEDaRT4_DpOT5_:
  103|  10.3k|   {
  104|  10.3k|      if constexpr( !Control< Rule >::enable ) {
  105|  10.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  10.3k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNSG_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  10.3k|      {
   44|  10.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.3k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEDaRT4_DpOT5_:
  103|  10.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.3k|      else {
  108|  10.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.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|  10.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.3k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  10.3k|            else if constexpr( has_apply0_bool ) {
  153|  10.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.3k|            }
  155|  10.3k|         }
  156|  10.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.3k, False: 0]
  ------------------
  157|  10.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.3k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  10.3k|         (void)m( result );
  163|  10.3k|         return result;
  164|  10.3k|      }
  165|  10.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSE_4RuleEEEEDaRT4_DpOT5_:
   72|  10.3k|      {
   73|  10.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.3k|         else {
   84|  10.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSE_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  10.3k|      {
   44|  10.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.3k|      }
_ZN3tao5pegtl5matchINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|   523k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   523k|      else {
  108|   523k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   523k|         using iterator_t = typename ParseInput::iterator_t;
  111|   523k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   523k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   523k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   523k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   523k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   523k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   523k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   523k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   523k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   523k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   523k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   523k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   523k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   523k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   523k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   523k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   523k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   523k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 513k, False: 10.3k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   513k|            else if constexpr( has_apply0_bool ) {
  153|   513k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   513k|            }
  155|   513k|         }
  156|   523k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 513k, False: 10.3k]
  ------------------
  157|   513k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   513k|         }
  159|  10.3k|         else {
  160|  10.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.3k|         }
  162|   523k|         (void)m( result );
  163|   523k|         return result;
  164|   523k|      }
  165|   523k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSC_4RuleEEEEDaRT4_DpOT5_:
   72|   523k|      {
   73|   523k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   523k|         else {
   84|   523k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   523k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   523k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSC_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   523k|      {
   44|   523k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   523k|      }
_ZN3tao5pegtl5matchINS0_6not_atIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   523k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   523k|      else {
  108|   523k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   523k|         using iterator_t = typename ParseInput::iterator_t;
  111|   523k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   523k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   523k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   523k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   523k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   523k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   523k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   523k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   523k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   523k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   523k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   523k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   523k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   523k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   523k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   523k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   523k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   523k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 513k, False: 10.3k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   513k|            else if constexpr( has_apply0_bool ) {
  153|   513k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   513k|            }
  155|   513k|         }
  156|   523k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 513k, False: 10.3k]
  ------------------
  157|   513k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   513k|         }
  159|  10.3k|         else {
  160|  10.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.3k|         }
  162|   523k|         (void)m( result );
  163|   523k|         return result;
  164|   523k|      }
  165|   523k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_6not_atIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   523k|      {
   73|   523k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   523k|         else {
   84|   523k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   523k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   523k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_6not_atIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   523k|      {
   44|   523k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   523k|      }
_ZN3tao5pegtl5matchINS0_3eofELNS0_10apply_modeE0ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   523k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   523k|      else {
  108|   523k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   523k|         using iterator_t = typename ParseInput::iterator_t;
  111|   523k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [Folded, False: 523k]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   523k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [Folded, False: 523k]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   523k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   523k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded, False: 523k]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   523k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded, False: 523k]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   523k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   523k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   523k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   523k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   523k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   523k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   523k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   523k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   523k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   523k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   523k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   523k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   523k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.3k, False: 513k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  10.3k|            else if constexpr( has_apply0_bool ) {
  153|  10.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.3k|            }
  155|  10.3k|         }
  156|   523k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.3k, False: 513k]
  ------------------
  157|  10.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.3k|         }
  159|   513k|         else {
  160|   513k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   513k|         }
  162|   523k|         (void)m( result );
  163|   523k|         return result;
  164|   523k|      }
  165|   523k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3eofELNS0_10apply_modeE0ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
   72|   523k|      {
   73|   523k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   523k|         else {
   84|   523k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   523k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   523k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3eofELNS0_10apply_modeE0ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS6_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   523k|      {
   59|   523k|         return Rule::match( in );
   60|   523k|      }
_ZN3tao5pegtl5matchINS0_5ascii3anyELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   513k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   513k|      else {
  108|   513k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   513k|         using iterator_t = typename ParseInput::iterator_t;
  111|   513k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   513k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   513k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   513k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   513k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   513k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   513k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   513k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   513k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   513k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   513k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   513k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   513k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   513k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   513k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   513k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   513k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   513k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 513k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   513k|            else if constexpr( has_apply0_bool ) {
  153|   513k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   513k|            }
  155|   513k|         }
  156|   513k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 513k, False: 0]
  ------------------
  157|   513k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   513k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   513k|         (void)m( result );
  163|   513k|         return result;
  164|   513k|      }
  165|   513k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3anyELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   513k|      {
   73|   513k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   513k|         else {
   84|   513k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   513k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   513k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3anyELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   513k|      {
   59|   513k|         return Rule::match( in );
   60|   513k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4ruleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.4k|      else {
  108|  38.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.6k, False: 4.73k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  33.6k|            else if constexpr( has_apply0_bool ) {
  153|  33.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.6k|            }
  155|  33.6k|         }
  156|  38.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.6k, False: 4.73k]
  ------------------
  157|  33.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.6k|         }
  159|  4.73k|         else {
  160|  4.73k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.73k|         }
  162|  38.4k|         (void)m( result );
  163|  38.4k|         return result;
  164|  38.4k|      }
  165|  38.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser4ruleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.4k|      {
   73|  38.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.4k|         else {
   84|  38.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser4ruleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.4k|      {
   44|  38.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6targetELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.4k|      else {
  108|  38.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  38.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 38.4k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 38.4k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.2k, False: 104]
  ------------------
  143|  38.2k|            if constexpr( has_apply_void ) {
  144|  38.2k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  38.2k|         }
  156|  38.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.2k, False: 104]
  ------------------
  157|  38.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.2k|         }
  159|    104|         else {
  160|    104|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    104|         }
  162|  38.4k|         (void)m( result );
  163|  38.4k|         return result;
  164|  38.4k|      }
  165|  38.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser6targetELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.4k|      {
   73|  38.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.4k|         else {
   84|  38.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser6targetELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.4k|      {
   44|  38.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_allowELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.4k|      else {
  108|  38.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 34.5k, False: 3.80k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  34.5k|            else if constexpr( has_apply0_bool ) {
  153|  34.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  34.5k|            }
  155|  34.5k|         }
  156|  38.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 34.5k, False: 3.80k]
  ------------------
  157|  34.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  34.5k|         }
  159|  3.80k|         else {
  160|  3.80k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.80k|         }
  162|  38.4k|         (void)m( result );
  163|  38.4k|         return result;
  164|  38.4k|      }
  165|  38.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9str_allowELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.4k|      {
   73|  38.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.4k|         else {
   84|  38.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9str_allowELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  38.4k|      {
   59|  38.4k|         return Rule::match( in );
   60|  38.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_blockELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.80k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.80k|      else {
  108|  3.80k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.80k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.80k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.80k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.80k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.80k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.80k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.80k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.80k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.80k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.80k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.80k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.80k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.80k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.80k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.80k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.80k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.80k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.80k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.71k, False: 1.09k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.71k|            else if constexpr( has_apply0_bool ) {
  153|  2.71k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.71k|            }
  155|  2.71k|         }
  156|  3.80k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.71k, False: 1.09k]
  ------------------
  157|  2.71k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.71k|         }
  159|  1.09k|         else {
  160|  1.09k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.09k|         }
  162|  3.80k|         (void)m( result );
  163|  3.80k|         return result;
  164|  3.80k|      }
  165|  3.80k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9str_blockELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.80k|      {
   73|  3.80k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.80k|         else {
   84|  3.80k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.80k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.80k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9str_blockELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.80k|      {
   59|  3.80k|         return Rule::match( in );
   60|  3.80k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_rejectELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.09k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.09k|      else {
  108|  1.09k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.09k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.09k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.09k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.09k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.09k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.09k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.09k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.09k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.09k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.09k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.09k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.09k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.09k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.09k|         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.09k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.09k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.09k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.09k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.09k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14, False: 1.07k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|     14|            else if constexpr( has_apply0_bool ) {
  153|     14|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     14|            }
  155|     14|         }
  156|  1.09k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14, False: 1.07k]
  ------------------
  157|     14|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     14|         }
  159|  1.07k|         else {
  160|  1.07k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.07k|         }
  162|  1.09k|         (void)m( result );
  163|  1.09k|         return result;
  164|  1.09k|      }
  165|  1.09k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_rejectELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.09k|      {
   73|  1.09k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.09k|         else {
   84|  1.09k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.09k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.09k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_rejectELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.09k|      {
   59|  1.09k|         return Rule::match( in );
   60|  1.09k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_matchELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.07k|      else {
  108|  1.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.07k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.07k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.07k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.07k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.07k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.07k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.07k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.07k|         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.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 925, False: 152]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    925|            else if constexpr( has_apply0_bool ) {
  153|    925|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    925|            }
  155|    925|         }
  156|  1.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 925, False: 152]
  ------------------
  157|    925|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    925|         }
  159|    152|         else {
  160|    152|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    152|         }
  162|  1.07k|         (void)m( result );
  163|  1.07k|         return result;
  164|  1.07k|      }
  165|  1.07k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9str_matchELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.07k|      {
   73|  1.07k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.07k|         else {
   84|  1.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.07k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9str_matchELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.07k|      {
   59|  1.07k|         return Rule::match( in );
   60|  1.07k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_deviceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|    152|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    152|      else {
  108|    152|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    152|         using iterator_t = typename ParseInput::iterator_t;
  111|    152|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    152|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    152|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    152|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    152|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    152|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    152|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    152|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    152|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    152|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    152|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    152|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    152|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    152|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    152|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    152|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    152|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    152|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 48, False: 104]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|     48|            else if constexpr( has_apply0_bool ) {
  153|     48|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     48|            }
  155|     48|         }
  156|    152|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 48, False: 104]
  ------------------
  157|     48|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     48|         }
  159|    104|         else {
  160|    104|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    104|         }
  162|    152|         (void)m( result );
  163|    152|         return result;
  164|    152|      }
  165|    152|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_deviceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|    152|      {
   73|    152|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    152|         else {
   84|    152|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    152|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    152|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_deviceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|    152|      {
   59|    152|         return Rule::match( in );
   60|    152|      }
_ZN3tao5pegtl5matchINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  38.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.2k|      else {
  108|  38.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.2k, False: 2]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  38.2k|            else if constexpr( has_apply0_bool ) {
  153|  38.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.2k|            }
  155|  38.2k|         }
  156|  38.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.2k, False: 2]
  ------------------
  157|  38.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.2k|         }
  159|      2|         else {
  160|      2|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      2|         }
  162|  38.2k|         (void)m( result );
  163|  38.2k|         return result;
  164|  38.2k|      }
  165|  38.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  38.2k|      {
   73|  38.2k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.2k|         else {
   84|  38.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.2k|      {
   44|  38.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.2k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  38.2k|   {
  104|  38.2k|      if constexpr( !Control< Rule >::enable ) {
  105|  38.2k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  38.2k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.2k|      {
   44|  38.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.2k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   105k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   105k|      else {
  108|   105k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   105k|         using iterator_t = typename ParseInput::iterator_t;
  111|   105k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   105k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   105k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   105k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   105k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   105k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   105k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   105k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   105k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   105k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   105k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   105k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   105k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   105k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   105k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   105k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   105k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   105k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 80.0k, False: 25.8k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  80.0k|            else if constexpr( has_apply0_bool ) {
  153|  80.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  80.0k|            }
  155|  80.0k|         }
  156|   105k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 80.0k, False: 25.8k]
  ------------------
  157|  80.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  80.0k|         }
  159|  25.8k|         else {
  160|  25.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  25.8k|         }
  162|   105k|         (void)m( result );
  163|   105k|         return result;
  164|   105k|      }
  165|   105k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|   105k|      {
   73|   105k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   105k|         else {
   84|   105k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   105k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   105k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   105k|      {
   44|   105k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   105k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   105k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   105k|      else {
  108|   105k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   105k|         using iterator_t = typename ParseInput::iterator_t;
  111|   105k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   105k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   105k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   105k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   105k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   105k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   105k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   105k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   105k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   105k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   105k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   105k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   105k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   105k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   105k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   105k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   105k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   105k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 80.0k, False: 25.8k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  80.0k|            else if constexpr( has_apply0_bool ) {
  153|  80.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  80.0k|            }
  155|  80.0k|         }
  156|   105k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 80.0k, False: 25.8k]
  ------------------
  157|  80.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  80.0k|         }
  159|  25.8k|         else {
  160|  25.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  25.8k|         }
  162|   105k|         (void)m( result );
  163|   105k|         return result;
  164|   105k|      }
  165|   105k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   105k|      {
   73|   105k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   105k|         else {
   84|   105k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   105k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   105k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   105k|      {
   59|   105k|         return Rule::match( in );
   60|   105k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9device_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.2k|      else {
  108|  38.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  38.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 38.2k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 38.2k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.75k, False: 36.5k]
  ------------------
  143|  1.75k|            if constexpr( has_apply_void ) {
  144|  1.75k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.75k|         }
  156|  38.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.75k, False: 36.5k]
  ------------------
  157|  1.75k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.75k|         }
  159|  36.5k|         else {
  160|  36.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  36.5k|         }
  162|  38.2k|         (void)m( result );
  163|  38.2k|         return result;
  164|  38.2k|      }
  165|  38.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9device_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.2k|      {
   73|  38.2k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.2k|         else {
   84|  38.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9device_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.2k|      {
   44|  38.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.2k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.2k|      else {
  108|  38.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.78k, False: 36.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.78k|            else if constexpr( has_apply0_bool ) {
  153|  1.78k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.78k|            }
  155|  1.78k|         }
  156|  38.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.78k, False: 36.4k]
  ------------------
  157|  1.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.78k|         }
  159|  36.4k|         else {
  160|  36.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  36.4k|         }
  162|  38.2k|         (void)m( result );
  163|  38.2k|         return result;
  164|  38.2k|      }
  165|  38.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.2k|      {
   73|  38.2k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.2k|         else {
   84|  38.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.2k|      {
   44|  38.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.2k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  40.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  40.0k|      else {
  108|  40.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  40.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  40.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  40.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  40.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  40.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  40.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  40.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.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|  40.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  40.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.90k, False: 38.1k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.90k|            else if constexpr( has_apply0_bool ) {
  153|  1.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.90k|            }
  155|  1.90k|         }
  156|  40.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.90k, False: 38.1k]
  ------------------
  157|  1.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.90k|         }
  159|  38.1k|         else {
  160|  38.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  38.1k|         }
  162|  40.0k|         (void)m( result );
  163|  40.0k|         return result;
  164|  40.0k|      }
  165|  40.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  40.0k|      {
   73|  40.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  40.0k|         else {
   84|  40.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  40.0k|      {
   44|  40.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  40.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  45.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.8k|      else {
  108|  45.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  45.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  45.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  45.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  45.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  45.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  45.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  45.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.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|  45.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.67k, False: 38.1k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.67k|            else if constexpr( has_apply0_bool ) {
  153|  7.67k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.67k|            }
  155|  7.67k|         }
  156|  45.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.67k, False: 38.1k]
  ------------------
  157|  7.67k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.67k|         }
  159|  38.1k|         else {
  160|  38.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  38.1k|         }
  162|  45.8k|         (void)m( result );
  163|  45.8k|         return result;
  164|  45.8k|      }
  165|  45.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  45.8k|      {
   73|  45.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  45.8k|         else {
   84|  45.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  45.8k|      {
   59|  45.8k|         return Rule::match( in );
   60|  45.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  38.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.1k|      else {
  108|  38.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.63k, False: 36.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  38.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.63k, False: 36.4k]
  ------------------
  157|  1.63k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.63k|         }
  159|  36.4k|         else {
  160|  36.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  36.4k|         }
  162|  38.1k|         (void)m( result );
  163|  38.1k|         return result;
  164|  38.1k|      }
  165|  38.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  38.1k|      {
   73|  38.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.1k|         else {
   84|  38.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  38.1k|      {
   59|  38.1k|         return Rule::match( in );
   60|  38.1k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.78k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.78k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.78k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.78k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.78k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 1.76k, False: 25]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.76k|            else if constexpr( has_apply0_bool ) {
  153|  1.76k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.76k|            }
  155|  1.76k|         }
  156|  1.78k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.76k, False: 25]
  ------------------
  157|  1.76k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.76k|         }
  159|     25|         else {
  160|     25|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     25|         }
  162|  1.78k|         (void)m( result );
  163|  1.78k|         return result;
  164|  1.78k|      }
  165|  1.78k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.78k|      {
   73|  1.78k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.78k|      {
   59|  1.78k|         return Rule::match( in );
   60|  1.78k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.76k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.76k|      else {
  108|  1.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.75k, False: 8]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.75k|            else if constexpr( has_apply0_bool ) {
  153|  1.75k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.75k|            }
  155|  1.75k|         }
  156|  1.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.75k, False: 8]
  ------------------
  157|  1.75k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.75k|         }
  159|      8|         else {
  160|      8|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      8|         }
  162|  1.76k|         (void)m( result );
  163|  1.76k|         return result;
  164|  1.76k|      }
  165|  1.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.76k|      {
   73|  1.76k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.76k|         else {
   84|  1.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  1.76k|      {
   44|  1.76k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.76k|      }
_ZN3tao5pegtl5matchINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  38.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.2k|      else {
  108|  38.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.6k, False: 4.62k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  33.6k|            else if constexpr( has_apply0_bool ) {
  153|  33.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.6k|            }
  155|  33.6k|         }
  156|  38.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.6k, False: 4.62k]
  ------------------
  157|  33.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.6k|         }
  159|  4.62k|         else {
  160|  4.62k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.62k|         }
  162|  38.2k|         (void)m( result );
  163|  38.2k|         return result;
  164|  38.2k|      }
  165|  38.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENSA_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  38.2k|      {
   73|  38.2k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.2k|         else {
   84|  38.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENSA_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.2k|      {
   44|  38.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.2k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENSA_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
  103|  38.2k|   {
  104|  38.2k|      if constexpr( !Control< Rule >::enable ) {
  105|  38.2k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  38.2k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENSA_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.2k|      {
   44|  38.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.2k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  37.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.0k|      else {
  108|  37.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  37.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  37.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  37.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  37.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  37.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  37.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  37.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.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|  37.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 25.9k, False: 11.0k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  25.9k|            else if constexpr( has_apply0_bool ) {
  153|  25.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  25.9k|            }
  155|  25.9k|         }
  156|  37.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 25.9k, False: 11.0k]
  ------------------
  157|  25.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  25.9k|         }
  159|  11.0k|         else {
  160|  11.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.0k|         }
  162|  37.0k|         (void)m( result );
  163|  37.0k|         return result;
  164|  37.0k|      }
  165|  37.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  37.0k|      {
   73|  37.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  37.0k|         else {
   84|  37.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  37.0k|      {
   44|  37.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15rule_attributesELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  41.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  41.8k|      else {
  108|  41.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  41.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  41.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  41.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  41.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  41.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  41.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  41.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.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|  41.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  41.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.3k, False: 12.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.3k|            else if constexpr( has_apply0_bool ) {
  153|  29.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.3k|            }
  155|  29.3k|         }
  156|  41.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.3k, False: 12.4k]
  ------------------
  157|  29.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.3k|         }
  159|  12.4k|         else {
  160|  12.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  12.4k|         }
  162|  41.8k|         (void)m( result );
  163|  41.8k|         return result;
  164|  41.8k|      }
  165|  41.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15rule_attributesELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  41.8k|      {
   73|  41.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  41.8k|         else {
   84|  41.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  41.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  41.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15rule_attributesELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  41.8k|      {
   44|  41.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  41.8k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12id_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  41.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  41.8k|      else {
  108|  41.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  41.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  41.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  41.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  41.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  41.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  41.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  41.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.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|  41.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  41.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.38k, False: 38.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.38k|            else if constexpr( has_apply0_bool ) {
  153|  3.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.38k|            }
  155|  3.38k|         }
  156|  41.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.38k, False: 38.4k]
  ------------------
  157|  3.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.38k|         }
  159|  38.4k|         else {
  160|  38.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  38.4k|         }
  162|  41.8k|         (void)m( result );
  163|  41.8k|         return result;
  164|  41.8k|      }
  165|  41.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12id_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  41.8k|      {
   73|  41.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  41.8k|         else {
   84|  41.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  41.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  41.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12id_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  41.8k|      {
   44|  41.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  41.8k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  41.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  41.8k|      else {
  108|  41.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  41.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  41.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  41.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  41.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  41.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  41.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  41.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.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|  41.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  41.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.38k, False: 38.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.38k|            else if constexpr( has_apply0_bool ) {
  153|  3.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.38k|            }
  155|  3.38k|         }
  156|  41.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.38k, False: 38.4k]
  ------------------
  157|  3.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.38k|         }
  159|  38.4k|         else {
  160|  38.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  38.4k|         }
  162|  41.8k|         (void)m( result );
  163|  41.8k|         return result;
  164|  41.8k|      }
  165|  41.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_6str_idENS4_15device_id_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  41.8k|      {
   73|  41.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  41.8k|         else {
   84|  41.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  41.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  41.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_6str_idENS4_15device_id_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  41.8k|      {
   44|  41.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  41.8k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6str_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  41.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  41.8k|      else {
  108|  41.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  41.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  41.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  41.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  41.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 41.8k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  41.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  41.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  41.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  41.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  41.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  41.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  41.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  41.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  41.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  41.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|  41.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 41.8k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  41.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  41.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  41.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  41.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.88k, False: 37.9k]
  ------------------
  143|  3.88k|            if constexpr( has_apply_void ) {
  144|  3.88k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  3.88k|         }
  156|  41.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.87k, False: 37.9k]
  ------------------
  157|  3.87k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.87k|         }
  159|  37.9k|         else {
  160|  37.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.9k|         }
  162|  41.8k|         (void)m( result );
  163|  41.8k|         return result;
  164|  41.8k|      }
  165|  41.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser6str_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  41.8k|      {
   73|  41.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  41.8k|         else {
   84|  41.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  41.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  41.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser6str_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  41.8k|      {
   59|  41.8k|         return Rule::match( in );
   60|  41.8k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   959k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   959k|      else {
  108|   959k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   959k|         using iterator_t = typename ParseInput::iterator_t;
  111|   959k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   959k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   959k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   959k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   959k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   959k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   959k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   959k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   959k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   959k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   959k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   959k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   959k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   959k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   959k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   959k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   959k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   959k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 958k, False: 1.11k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   958k|            else if constexpr( has_apply0_bool ) {
  153|   958k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   958k|            }
  155|   958k|         }
  156|   959k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 958k, False: 1.11k]
  ------------------
  157|   958k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   958k|         }
  159|  1.11k|         else {
  160|  1.11k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.11k|         }
  162|   959k|         (void)m( result );
  163|   959k|         return result;
  164|   959k|      }
  165|   959k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|   959k|      {
   73|   959k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   959k|         else {
   84|   959k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   959k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   959k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   959k|      {
   44|   959k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   959k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   959k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   959k|      else {
  108|   959k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   959k|         using iterator_t = typename ParseInput::iterator_t;
  111|   959k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   959k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   959k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   959k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   959k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   959k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   959k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   959k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   959k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   959k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   959k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   959k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   959k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   959k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   959k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   959k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   959k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   959k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 958k, False: 1.11k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   958k|            else if constexpr( has_apply0_bool ) {
  153|   958k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   958k|            }
  155|   958k|         }
  156|   959k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 958k, False: 1.11k]
  ------------------
  157|   958k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   958k|         }
  159|  1.11k|         else {
  160|  1.11k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.11k|         }
  162|   959k|         (void)m( result );
  163|   959k|         return result;
  164|   959k|      }
  165|   959k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   959k|      {
   73|   959k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   959k|         else {
   84|   959k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   959k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   959k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   959k|      {
   59|   959k|         return Rule::match( in );
   60|   959k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   974k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   974k|      else {
  108|   974k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   974k|         using iterator_t = typename ParseInput::iterator_t;
  111|   974k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   974k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   974k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   974k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   974k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   974k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   974k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   974k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   974k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   974k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   974k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   974k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   974k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   974k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   974k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   974k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   974k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   974k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.4k, False: 963k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  10.4k|            else if constexpr( has_apply0_bool ) {
  153|  10.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.4k|            }
  155|  10.4k|         }
  156|   974k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.4k, False: 963k]
  ------------------
  157|  10.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.4k|         }
  159|   963k|         else {
  160|   963k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   963k|         }
  162|   974k|         (void)m( result );
  163|   974k|         return result;
  164|   974k|      }
  165|   974k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   974k|      {
   73|   974k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   974k|         else {
   84|   974k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   974k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   974k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   974k|      {
   59|   974k|         return Rule::match( in );
   60|   974k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.85k|      else {
  108|  3.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.85k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.85k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.85k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.85k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.85k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.85k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.85k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.85k|         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.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.38k, False: 473]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.38k|            else if constexpr( has_apply0_bool ) {
  153|  3.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.38k|            }
  155|  3.38k|         }
  156|  3.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.38k, False: 473]
  ------------------
  157|  3.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.38k|         }
  159|    473|         else {
  160|    473|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    473|         }
  162|  3.85k|         (void)m( result );
  163|  3.85k|         return result;
  164|  3.85k|      }
  165|  3.85k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_15device_id_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.85k|      {
   73|  3.85k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.85k|         else {
   84|  3.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.85k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_15device_id_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.85k|      {
   44|  3.85k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.85k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.85k|      else {
  108|  3.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.85k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.85k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.85k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.85k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.85k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.85k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.85k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.85k|         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.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.35k, False: 1.50k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.35k|            else if constexpr( has_apply0_bool ) {
  153|  2.35k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.35k|            }
  155|  2.35k|         }
  156|  3.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.35k, False: 1.50k]
  ------------------
  157|  2.35k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.35k|         }
  159|  1.50k|         else {
  160|  1.50k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.50k|         }
  162|  3.85k|         (void)m( result );
  163|  3.85k|         return result;
  164|  3.85k|      }
  165|  3.85k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.85k|      {
   73|  3.85k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.85k|         else {
   84|  3.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.85k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.85k|      {
   44|  3.85k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.85k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.85k|      else {
  108|  3.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.85k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.85k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.85k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.85k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.85k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.85k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.85k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.85k|         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.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.85k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.85k|            else if constexpr( has_apply0_bool ) {
  153|  3.85k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.85k|            }
  155|  3.85k|         }
  156|  3.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.85k, False: 0]
  ------------------
  157|  3.85k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.85k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.85k|         (void)m( result );
  163|  3.85k|         return result;
  164|  3.85k|      }
  165|  3.85k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.85k|      {
   73|  3.85k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.85k|         else {
   84|  3.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.85k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.85k|      {
   44|  3.85k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.85k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.85k|   {
  104|  3.85k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.85k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.85k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.85k|      {
   44|  3.85k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.85k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.85k|      else {
  108|  3.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.85k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.85k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.85k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.85k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.85k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.85k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.85k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.85k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.85k|         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.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.85k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.97k, False: 1.88k]
  ------------------
  143|  1.97k|            if constexpr( has_apply_void ) {
  144|  1.97k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.97k|         }
  156|  3.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.97k, False: 1.88k]
  ------------------
  157|  1.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.97k|         }
  159|  1.88k|         else {
  160|  1.88k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.88k|         }
  162|  3.85k|         (void)m( result );
  163|  3.85k|         return result;
  164|  3.85k|      }
  165|  3.85k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.85k|      {
   73|  3.85k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.85k|         else {
   84|  3.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.85k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.85k|      {
   44|  3.85k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.85k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.85k|      else {
  108|  3.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.85k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.85k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.85k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.85k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.85k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.85k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.85k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.85k|         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.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 223, False: 3.63k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    223|            else if constexpr( has_apply0_bool ) {
  153|    223|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    223|            }
  155|    223|         }
  156|  3.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 223, False: 3.63k]
  ------------------
  157|    223|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    223|         }
  159|  3.63k|         else {
  160|  3.63k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.63k|         }
  162|  3.85k|         (void)m( result );
  163|  3.85k|         return result;
  164|  3.85k|      }
  165|  3.85k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.85k|      {
   73|  3.85k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.85k|         else {
   84|  3.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.85k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.85k|      {
   59|  3.85k|         return Rule::match( in );
   60|  3.85k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.63k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.63k|      else {
  108|  3.63k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.63k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.63k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.63k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.63k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.63k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.63k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.63k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.63k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.63k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.63k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.63k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.63k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.63k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.63k|         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.63k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.63k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.63k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.63k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.63k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 212, False: 3.42k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    212|            else if constexpr( has_apply0_bool ) {
  153|    212|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    212|            }
  155|    212|         }
  156|  3.63k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 212, False: 3.42k]
  ------------------
  157|    212|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    212|         }
  159|  3.42k|         else {
  160|  3.42k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.42k|         }
  162|  3.63k|         (void)m( result );
  163|  3.63k|         return result;
  164|  3.63k|      }
  165|  3.63k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.63k|      {
   73|  3.63k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.63k|         else {
   84|  3.63k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.63k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.63k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.63k|      {
   59|  3.63k|         return Rule::match( in );
   60|  3.63k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.42k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.42k|      else {
  108|  3.42k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.42k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.42k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.42k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.42k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.42k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.42k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.42k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.42k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.42k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.42k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.42k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.42k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.42k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.42k|         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.42k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.42k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.42k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.42k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.42k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 215, False: 3.20k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    215|            else if constexpr( has_apply0_bool ) {
  153|    215|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    215|            }
  155|    215|         }
  156|  3.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 215, False: 3.20k]
  ------------------
  157|    215|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    215|         }
  159|  3.20k|         else {
  160|  3.20k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.20k|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.42k|      {
   73|  3.42k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.42k|         else {
   84|  3.42k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.42k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.42k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.42k|      {
   59|  3.42k|         return Rule::match( in );
   60|  3.42k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.20k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.20k|      else {
  108|  3.20k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.20k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.20k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.20k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.20k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.20k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.20k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.20k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.20k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.20k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.20k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.20k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.20k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.20k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.20k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.20k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.20k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.20k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.20k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 688, False: 2.52k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    688|            else if constexpr( has_apply0_bool ) {
  153|    688|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    688|            }
  155|    688|         }
  156|  3.20k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 688, False: 2.52k]
  ------------------
  157|    688|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    688|         }
  159|  2.52k|         else {
  160|  2.52k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.52k|         }
  162|  3.20k|         (void)m( result );
  163|  3.20k|         return result;
  164|  3.20k|      }
  165|  3.20k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.20k|      {
   73|  3.20k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.20k|         else {
   84|  3.20k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.20k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.20k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.20k|      {
   59|  3.20k|         return Rule::match( in );
   60|  3.20k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.52k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.52k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.52k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.52k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.52k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 437, False: 2.08k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    437|            else if constexpr( has_apply0_bool ) {
  153|    437|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    437|            }
  155|    437|         }
  156|  2.52k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 437, False: 2.08k]
  ------------------
  157|    437|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    437|         }
  159|  2.08k|         else {
  160|  2.08k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.08k|         }
  162|  2.52k|         (void)m( result );
  163|  2.52k|         return result;
  164|  2.52k|      }
  165|  2.52k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.08k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.08k|      else {
  108|  2.08k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.08k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.08k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.08k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.08k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.08k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.08k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.08k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.08k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.08k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.08k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.08k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.08k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.08k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.08k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.08k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.08k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.08k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.08k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 202, False: 1.88k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    202|            else if constexpr( has_apply0_bool ) {
  153|    202|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    202|            }
  155|    202|         }
  156|  2.08k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 202, False: 1.88k]
  ------------------
  157|    202|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    202|         }
  159|  1.88k|         else {
  160|  1.88k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.88k|         }
  162|  2.08k|         (void)m( result );
  163|  2.08k|         return result;
  164|  2.08k|      }
  165|  2.08k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.08k|      {
   73|  2.08k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.08k|         else {
   84|  2.08k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.08k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.08k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.08k|      {
   59|  2.08k|         return Rule::match( in );
   60|  2.08k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.85k|      else {
  108|  3.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.85k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.85k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.85k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.85k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.85k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.85k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.85k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.85k|         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.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.59k, False: 1.26k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.59k|            else if constexpr( has_apply0_bool ) {
  153|  2.59k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.59k|            }
  155|  2.59k|         }
  156|  3.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.59k, False: 1.26k]
  ------------------
  157|  2.59k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.59k|         }
  159|  1.26k|         else {
  160|  1.26k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.26k|         }
  162|  3.85k|         (void)m( result );
  163|  3.85k|         return result;
  164|  3.85k|      }
  165|  3.85k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.85k|      {
   73|  3.85k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.85k|         else {
   84|  3.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.85k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.85k|      {
   59|  3.85k|         return Rule::match( in );
   60|  3.85k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.10k|      else {
  108|  5.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.10k|         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.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.10k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.10k|            else if constexpr( has_apply0_bool ) {
  153|  5.10k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.10k|            }
  155|  5.10k|         }
  156|  5.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.10k, False: 0]
  ------------------
  157|  5.10k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.10k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  5.10k|         (void)m( result );
  163|  5.10k|         return result;
  164|  5.10k|      }
  165|  5.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  5.10k|      {
   73|  5.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.10k|         else {
   84|  5.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.10k|      {
   44|  5.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.10k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.59k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.59k|      else {
  108|  2.59k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.59k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.59k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.59k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.59k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.59k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.59k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.59k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.59k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.59k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.59k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.59k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.59k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.59k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.59k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.59k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.59k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.59k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.59k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.51k, False: 78]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.51k|            else if constexpr( has_apply0_bool ) {
  153|  2.51k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.51k|            }
  155|  2.51k|         }
  156|  2.59k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.51k, False: 78]
  ------------------
  157|  2.51k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.51k|         }
  159|     78|         else {
  160|     78|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     78|         }
  162|  2.59k|         (void)m( result );
  163|  2.59k|         return result;
  164|  2.59k|      }
  165|  2.59k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.59k|      {
   73|  2.59k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.59k|         else {
   84|  2.59k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.59k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.59k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.59k|      {
   44|  2.59k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.59k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15device_id_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.51k|   {
  104|  2.51k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.51k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.51k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15device_id_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.51k|      {
   44|  2.51k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.51k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15device_id_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   953k|   {
  104|   953k|      if constexpr( !Control< Rule >::enable ) {
  105|   953k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   953k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15device_id_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   953k|      {
   44|   953k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   953k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.51k|      else {
  108|  2.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.51k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.51k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.51k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.51k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.51k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.51k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.51k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.35k, False: 161]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.35k|            else if constexpr( has_apply0_bool ) {
  153|  2.35k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.35k|            }
  155|  2.35k|         }
  156|  2.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.35k, False: 161]
  ------------------
  157|  2.35k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.35k|         }
  159|    161|         else {
  160|    161|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    161|         }
  162|  2.51k|         (void)m( result );
  163|  2.51k|         return result;
  164|  2.51k|      }
  165|  2.51k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.51k|      {
   73|  2.51k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.51k|         else {
   84|  2.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.51k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.51k|      {
   59|  2.51k|         return Rule::match( in );
   60|  2.51k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15device_id_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   956k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   956k|      else {
  108|   956k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   956k|         using iterator_t = typename ParseInput::iterator_t;
  111|   956k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|   956k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   956k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 956k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   956k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   956k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   956k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   956k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   956k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   956k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   956k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   956k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   956k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   956k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   956k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 956k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   956k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   956k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   956k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   956k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 954k, False: 1.99k]
  ------------------
  143|   954k|            if constexpr( has_apply_void ) {
  144|   954k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|   954k|         }
  156|   956k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 954k, False: 2.00k]
  ------------------
  157|   954k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   954k|         }
  159|  2.00k|         else {
  160|  2.00k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.00k|         }
  162|   956k|         (void)m( result );
  163|   956k|         return result;
  164|   956k|      }
  165|   956k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15device_id_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   956k|      {
   73|   956k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   956k|         else {
   84|   956k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   956k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   956k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15device_id_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   956k|      {
   44|   956k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   956k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   956k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   956k|      else {
  108|   956k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   956k|         using iterator_t = typename ParseInput::iterator_t;
  111|   956k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   956k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   956k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   956k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   956k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   956k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   956k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   956k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   956k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   956k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   956k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   956k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   956k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   956k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   956k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   956k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   956k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   956k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 954k, False: 1.92k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   954k|            else if constexpr( has_apply0_bool ) {
  153|   954k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   954k|            }
  155|   954k|         }
  156|   956k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 954k, False: 1.92k]
  ------------------
  157|   954k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   954k|         }
  159|  1.92k|         else {
  160|  1.92k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.92k|         }
  162|   956k|         (void)m( result );
  163|   956k|         return result;
  164|   956k|      }
  165|   956k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   956k|      {
   73|   956k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   956k|         else {
   84|   956k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   956k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   956k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   956k|      {
   44|   956k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   956k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.91M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.91M|      else {
  108|  1.91M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.91M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.91M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.91M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.91M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.91M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.91M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.91M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.91M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.91M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.91M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.91M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.91M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.91M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.91M|         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.91M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.91M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.91M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.91M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.91M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.35k, False: 1.90M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.35k|            else if constexpr( has_apply0_bool ) {
  153|  2.35k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.35k|            }
  155|  2.35k|         }
  156|  1.91M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.35k, False: 1.90M]
  ------------------
  157|  2.35k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.35k|         }
  159|  1.90M|         else {
  160|  1.90M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.90M|         }
  162|  1.91M|         (void)m( result );
  163|  1.91M|         return result;
  164|  1.91M|      }
  165|  1.91M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.91M|      {
   73|  1.91M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.91M|         else {
   84|  1.91M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.91M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.91M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  1.91M|      {
   44|  1.91M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.91M|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  1.91M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.91M|      else {
  108|  1.91M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.91M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.91M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.91M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.91M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.91M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.91M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.91M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.91M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.91M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.91M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.91M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.91M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.91M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.91M|         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.91M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.91M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.91M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.91M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.91M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.58k, False: 1.90M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  9.58k|            else if constexpr( has_apply0_bool ) {
  153|  9.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.58k|            }
  155|  9.58k|         }
  156|  1.91M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.58k, False: 1.90M]
  ------------------
  157|  9.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.58k|         }
  159|  1.90M|         else {
  160|  1.90M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.90M|         }
  162|  1.91M|         (void)m( result );
  163|  1.91M|         return result;
  164|  1.91M|      }
  165|  1.91M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  1.91M|      {
   73|  1.91M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.91M|         else {
   84|  1.91M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.91M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.91M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.91M|      {
   59|  1.91M|         return Rule::match( in );
   60|  1.91M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.90M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.90M|      else {
  108|  1.90M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.90M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.90M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.90M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.90M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.90M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.90M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.90M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.90M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.90M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.90M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.90M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.90M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.90M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.90M|         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.90M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.90M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.90M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.90M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.90M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.90M, False: 1.94k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.90M|            else if constexpr( has_apply0_bool ) {
  153|  1.90M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.90M|            }
  155|  1.90M|         }
  156|  1.90M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.90M, False: 1.94k]
  ------------------
  157|  1.90M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.90M|         }
  159|  1.94k|         else {
  160|  1.94k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.94k|         }
  162|  1.90M|         (void)m( result );
  163|  1.90M|         return result;
  164|  1.90M|      }
  165|  1.90M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.90M|      {
   73|  1.90M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.90M|         else {
   84|  1.90M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.90M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.90M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.90M|      {
   59|  1.90M|         return Rule::match( in );
   60|  1.90M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   954k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   954k|      else {
  108|   954k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   954k|         using iterator_t = typename ParseInput::iterator_t;
  111|   954k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   954k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   954k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   954k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   954k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   954k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   954k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   954k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   954k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   954k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   954k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   954k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   954k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   954k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   954k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   954k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   954k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   954k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 954k, False: 51]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   954k|            else if constexpr( has_apply0_bool ) {
  153|   954k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   954k|            }
  155|   954k|         }
  156|   954k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 954k, False: 51]
  ------------------
  157|   954k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   954k|         }
  159|     51|         else {
  160|     51|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     51|         }
  162|   954k|         (void)m( result );
  163|   954k|         return result;
  164|   954k|      }
  165|   954k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   954k|      {
   73|   954k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   954k|         else {
   84|   954k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   954k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   954k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   954k|      {
   59|   954k|         return Rule::match( in );
   60|   954k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   954k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   954k|      else {
  108|   954k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   954k|         using iterator_t = typename ParseInput::iterator_t;
  111|   954k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   954k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   954k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   954k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   954k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   954k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   954k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   954k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   954k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   954k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   954k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   954k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   954k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   954k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   954k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   954k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   954k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   954k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 954k, False: 24]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   954k|            else if constexpr( has_apply0_bool ) {
  153|   954k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   954k|            }
  155|   954k|         }
  156|   954k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 954k, False: 24]
  ------------------
  157|   954k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   954k|         }
  159|     24|         else {
  160|     24|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     24|         }
  162|   954k|         (void)m( result );
  163|   954k|         return result;
  164|   954k|      }
  165|   954k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   954k|      {
   73|   954k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   954k|         else {
   84|   954k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   954k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   954k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   954k|      {
   44|   954k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   954k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14name_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.4k|      else {
  108|  38.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.90k, False: 35.5k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.90k|            else if constexpr( has_apply0_bool ) {
  153|  2.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.90k|            }
  155|  2.90k|         }
  156|  38.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.90k, False: 35.5k]
  ------------------
  157|  2.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.90k|         }
  159|  35.5k|         else {
  160|  35.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  35.5k|         }
  162|  38.4k|         (void)m( result );
  163|  38.4k|         return result;
  164|  38.4k|      }
  165|  38.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14name_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.4k|      {
   73|  38.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.4k|         else {
   84|  38.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14name_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.4k|      {
   44|  38.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.4k|      else {
  108|  38.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.90k, False: 35.5k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.90k|            else if constexpr( has_apply0_bool ) {
  153|  2.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.90k|            }
  155|  2.90k|         }
  156|  38.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.90k, False: 35.5k]
  ------------------
  157|  2.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.90k|         }
  159|  35.5k|         else {
  160|  35.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  35.5k|         }
  162|  38.4k|         (void)m( result );
  163|  38.4k|         return result;
  164|  38.4k|      }
  165|  38.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_8str_nameENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.4k|      {
   73|  38.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.4k|         else {
   84|  38.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_8str_nameENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  38.4k|      {
   44|  38.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8str_nameELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  38.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.4k|      else {
  108|  38.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  38.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 38.4k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  38.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  38.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  38.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  38.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  38.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 38.4k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.62k, False: 34.7k]
  ------------------
  143|  3.62k|            if constexpr( has_apply_void ) {
  144|  3.62k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  3.62k|         }
  156|  38.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.62k, False: 34.7k]
  ------------------
  157|  3.62k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.62k|         }
  159|  34.7k|         else {
  160|  34.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  34.7k|         }
  162|  38.4k|         (void)m( result );
  163|  38.4k|         return result;
  164|  38.4k|      }
  165|  38.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser8str_nameELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  38.4k|      {
   73|  38.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  38.4k|         else {
   84|  38.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser8str_nameELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  38.4k|      {
   59|  38.4k|         return Rule::match( in );
   60|  38.4k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   315k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   315k|      else {
  108|   315k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   315k|         using iterator_t = typename ParseInput::iterator_t;
  111|   315k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   315k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   315k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   315k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   315k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   315k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   315k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   315k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   315k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   315k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   315k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   315k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   315k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   315k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   315k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   315k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   315k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   315k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 314k, False: 1.87k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   314k|            else if constexpr( has_apply0_bool ) {
  153|   314k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   314k|            }
  155|   314k|         }
  156|   315k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 314k, False: 1.87k]
  ------------------
  157|   314k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   314k|         }
  159|  1.87k|         else {
  160|  1.87k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.87k|         }
  162|   315k|         (void)m( result );
  163|   315k|         return result;
  164|   315k|      }
  165|   315k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|   315k|      {
   73|   315k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   315k|         else {
   84|   315k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   315k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   315k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   315k|      {
   44|   315k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   315k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   315k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   315k|      else {
  108|   315k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   315k|         using iterator_t = typename ParseInput::iterator_t;
  111|   315k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   315k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   315k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   315k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   315k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   315k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   315k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   315k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   315k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   315k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   315k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   315k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   315k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   315k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   315k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   315k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   315k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   315k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 314k, False: 1.87k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   314k|            else if constexpr( has_apply0_bool ) {
  153|   314k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   314k|            }
  155|   314k|         }
  156|   315k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 314k, False: 1.87k]
  ------------------
  157|   314k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   314k|         }
  159|  1.87k|         else {
  160|  1.87k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.87k|         }
  162|   315k|         (void)m( result );
  163|   315k|         return result;
  164|   315k|      }
  165|   315k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   315k|      {
   73|   315k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   315k|         else {
   84|   315k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   315k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   315k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   315k|      {
   59|   315k|         return Rule::match( in );
   60|   315k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   323k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   323k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   323k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   323k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   323k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 5.04k, False: 318k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.04k|            else if constexpr( has_apply0_bool ) {
  153|  5.04k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.04k|            }
  155|  5.04k|         }
  156|   323k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.04k, False: 318k]
  ------------------
  157|  5.04k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.04k|         }
  159|   318k|         else {
  160|   318k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   318k|         }
  162|   323k|         (void)m( result );
  163|   323k|         return result;
  164|   323k|      }
  165|   323k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   323k|      {
   73|   323k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_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_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.60k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.60k|      else {
  108|  3.60k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.60k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.60k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.60k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.60k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.60k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.60k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.60k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.60k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.60k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.60k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.60k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.60k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.60k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.60k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.60k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.60k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.60k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.60k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.90k, False: 706]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.90k|            else if constexpr( has_apply0_bool ) {
  153|  2.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.90k|            }
  155|  2.90k|         }
  156|  3.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.90k, False: 706]
  ------------------
  157|  2.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.90k|         }
  159|    706|         else {
  160|    706|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    706|         }
  162|  3.60k|         (void)m( result );
  163|  3.60k|         return result;
  164|  3.60k|      }
  165|  3.60k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.60k|      {
   73|  3.60k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.60k|         else {
   84|  3.60k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.60k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.60k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.60k|      {
   44|  3.60k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.60k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.60k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.60k|      else {
  108|  3.60k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.60k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.60k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.60k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.60k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.60k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.60k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.60k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.60k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.60k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.60k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.60k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.60k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.60k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.60k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.60k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.60k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.60k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.60k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.26k, False: 1.34k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.26k|            else if constexpr( has_apply0_bool ) {
  153|  2.26k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.26k|            }
  155|  2.26k|         }
  156|  3.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.26k, False: 1.34k]
  ------------------
  157|  2.26k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.26k|         }
  159|  1.34k|         else {
  160|  1.34k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.34k|         }
  162|  3.60k|         (void)m( result );
  163|  3.60k|         return result;
  164|  3.60k|      }
  165|  3.60k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.60k|      {
   73|  3.60k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.60k|         else {
   84|  3.60k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.60k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.60k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.60k|      {
   44|  3.60k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.60k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.60k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.60k|      else {
  108|  3.60k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.60k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.60k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.60k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.60k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.60k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.60k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.60k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.60k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.60k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.60k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.60k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.60k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.60k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.60k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.60k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.60k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.60k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.60k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.60k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  3.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.60k, False: 0]
  ------------------
  157|  3.60k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.60k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.60k|         (void)m( result );
  163|  3.60k|         return result;
  164|  3.60k|      }
  165|  3.60k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.60k|      {
   73|  3.60k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.60k|         else {
   84|  3.60k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.60k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.60k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.60k|      {
   44|  3.60k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.60k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.60k|   {
  104|  3.60k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.60k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.60k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.60k|      {
   44|  3.60k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.60k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.60k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.60k|      else {
  108|  3.60k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.60k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.60k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.60k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.60k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.60k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.60k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.60k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.60k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.60k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.60k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.60k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.60k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.60k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.60k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.60k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.60k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.60k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.60k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.60k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.60k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.53k, False: 2.07k]
  ------------------
  143|  1.53k|            if constexpr( has_apply_void ) {
  144|  1.53k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.53k|         }
  156|  3.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.53k, False: 2.07k]
  ------------------
  157|  1.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.53k|         }
  159|  2.07k|         else {
  160|  2.07k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.07k|         }
  162|  3.60k|         (void)m( result );
  163|  3.60k|         return result;
  164|  3.60k|      }
  165|  3.60k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.60k|      {
   73|  3.60k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.60k|         else {
   84|  3.60k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.60k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.60k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.60k|      {
   44|  3.60k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.60k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.60k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.60k|      else {
  108|  3.60k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.60k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.60k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.60k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.60k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.60k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.60k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.60k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.60k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.60k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.60k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.60k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.60k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.60k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.60k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.60k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.60k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.60k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.60k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 202, False: 3.40k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    202|            else if constexpr( has_apply0_bool ) {
  153|    202|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    202|            }
  155|    202|         }
  156|  3.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 202, False: 3.40k]
  ------------------
  157|    202|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    202|         }
  159|  3.40k|         else {
  160|  3.40k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.40k|         }
  162|  3.60k|         (void)m( result );
  163|  3.60k|         return result;
  164|  3.60k|      }
  165|  3.60k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.60k|      {
   73|  3.60k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.60k|         else {
   84|  3.60k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.60k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.60k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.60k|      {
   59|  3.60k|         return Rule::match( in );
   60|  3.60k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.40k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.40k|      else {
  108|  3.40k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.40k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.40k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.40k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.40k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.40k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.40k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.40k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.40k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.40k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.40k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.40k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.40k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.40k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.40k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.40k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.40k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.40k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.40k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 422, False: 2.98k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    422|            else if constexpr( has_apply0_bool ) {
  153|    422|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    422|            }
  155|    422|         }
  156|  3.40k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 422, False: 2.98k]
  ------------------
  157|    422|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    422|         }
  159|  2.98k|         else {
  160|  2.98k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.98k|         }
  162|  3.40k|         (void)m( result );
  163|  3.40k|         return result;
  164|  3.40k|      }
  165|  3.40k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.40k|      {
   73|  3.40k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.40k|         else {
   84|  3.40k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.40k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.40k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.40k|      {
   59|  3.40k|         return Rule::match( in );
   60|  3.40k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.98k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.98k|      else {
  108|  2.98k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.98k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.98k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.98k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.98k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.98k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.98k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.98k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.98k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.98k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.98k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.98k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.98k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.98k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.98k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.98k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.98k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.98k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.98k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 285, False: 2.69k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    285|            else if constexpr( has_apply0_bool ) {
  153|    285|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    285|            }
  155|    285|         }
  156|  2.98k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 285, False: 2.69k]
  ------------------
  157|    285|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    285|         }
  159|  2.69k|         else {
  160|  2.69k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.69k|         }
  162|  2.98k|         (void)m( result );
  163|  2.98k|         return result;
  164|  2.98k|      }
  165|  2.98k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.98k|      {
   73|  2.98k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.98k|         else {
   84|  2.98k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.98k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.98k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.98k|      {
   59|  2.98k|         return Rule::match( in );
   60|  2.98k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.69k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.69k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.69k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.69k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.69k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 195, False: 2.50k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    195|            else if constexpr( has_apply0_bool ) {
  153|    195|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    195|            }
  155|    195|         }
  156|  2.69k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 195, False: 2.50k]
  ------------------
  157|    195|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    195|         }
  159|  2.50k|         else {
  160|  2.50k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.50k|         }
  162|  2.69k|         (void)m( result );
  163|  2.69k|         return result;
  164|  2.69k|      }
  165|  2.69k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.69k|      {
   73|  2.69k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.69k|      {
   59|  2.69k|         return Rule::match( in );
   60|  2.69k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.50k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.50k|      else {
  108|  2.50k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.50k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.50k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.50k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.50k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.50k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.50k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.50k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.50k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.50k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.50k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.50k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.50k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.50k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.50k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.50k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.50k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.50k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.50k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 229, False: 2.27k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    229|            else if constexpr( has_apply0_bool ) {
  153|    229|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    229|            }
  155|    229|         }
  156|  2.50k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 229, False: 2.27k]
  ------------------
  157|    229|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    229|         }
  159|  2.27k|         else {
  160|  2.27k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.27k|         }
  162|  2.50k|         (void)m( result );
  163|  2.50k|         return result;
  164|  2.50k|      }
  165|  2.50k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.50k|      {
   73|  2.50k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.50k|         else {
   84|  2.50k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.50k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.50k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.50k|      {
   59|  2.50k|         return Rule::match( in );
   60|  2.50k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.27k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.27k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.27k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.27k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.27k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 197, False: 2.07k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    197|            else if constexpr( has_apply0_bool ) {
  153|    197|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    197|            }
  155|    197|         }
  156|  2.27k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 197, False: 2.07k]
  ------------------
  157|    197|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    197|         }
  159|  2.07k|         else {
  160|  2.07k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.07k|         }
  162|  2.27k|         (void)m( result );
  163|  2.27k|         return result;
  164|  2.27k|      }
  165|  2.27k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.27k|      {
   73|  2.27k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.27k|      {
   59|  2.27k|         return Rule::match( in );
   60|  2.27k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.60k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.60k|      else {
  108|  3.60k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.60k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.60k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.60k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.60k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.60k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.60k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.60k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.60k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.60k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.60k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.60k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.60k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.60k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.60k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.60k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.60k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.60k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.60k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.46k, False: 1.13k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.46k|            else if constexpr( has_apply0_bool ) {
  153|  2.46k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.46k|            }
  155|  2.46k|         }
  156|  3.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.46k, False: 1.13k]
  ------------------
  157|  2.46k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.46k|         }
  159|  1.13k|         else {
  160|  1.13k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.13k|         }
  162|  3.60k|         (void)m( result );
  163|  3.60k|         return result;
  164|  3.60k|      }
  165|  3.60k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.60k|      {
   73|  3.60k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.60k|         else {
   84|  3.60k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.60k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.60k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.60k|      {
   59|  3.60k|         return Rule::match( in );
   60|  3.60k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.86k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.86k|      else {
  108|  4.86k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.86k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.86k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.86k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.86k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.86k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.86k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.86k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.86k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.86k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.86k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.86k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.86k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.86k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.86k|         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.86k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.86k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.86k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.86k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.86k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.86k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.86k|            else if constexpr( has_apply0_bool ) {
  153|  4.86k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.86k|            }
  155|  4.86k|         }
  156|  4.86k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.86k, False: 0]
  ------------------
  157|  4.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.86k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.86k|         (void)m( result );
  163|  4.86k|         return result;
  164|  4.86k|      }
  165|  4.86k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.86k|      {
   73|  4.86k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.86k|         else {
   84|  4.86k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.86k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.86k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.86k|      {
   44|  4.86k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.86k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.46k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.46k|      else {
  108|  2.46k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.46k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.46k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.46k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.46k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.46k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.46k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.46k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.46k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.46k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.46k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.46k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.46k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.46k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.46k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.46k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.46k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.46k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.46k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.39k, False: 74]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.39k|            else if constexpr( has_apply0_bool ) {
  153|  2.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.39k|            }
  155|  2.39k|         }
  156|  2.46k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.39k, False: 74]
  ------------------
  157|  2.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.39k|         }
  159|     74|         else {
  160|     74|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     74|         }
  162|  2.46k|         (void)m( result );
  163|  2.46k|         return result;
  164|  2.46k|      }
  165|  2.46k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.46k|      {
   73|  2.46k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.46k|         else {
   84|  2.46k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.46k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.46k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.46k|      {
   44|  2.46k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.46k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.41k|   {
  104|  2.41k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.41k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.41k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.41k|      {
   44|  2.41k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.41k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   310k|   {
  104|   310k|      if constexpr( !Control< Rule >::enable ) {
  105|   310k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   310k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   310k|      {
   44|   310k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   310k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.39k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.39k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.39k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.39k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.39k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 2.26k, False: 132]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.26k|            else if constexpr( has_apply0_bool ) {
  153|  2.26k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.26k|            }
  155|  2.26k|         }
  156|  2.39k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.26k, False: 132]
  ------------------
  157|  2.26k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.26k|         }
  159|    132|         else {
  160|    132|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    132|         }
  162|  2.39k|         (void)m( result );
  163|  2.39k|         return result;
  164|  2.39k|      }
  165|  2.39k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.39k|      {
   73|  2.39k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.39k|      {
   59|  2.39k|         return Rule::match( in );
   60|  2.39k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   312k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   312k|      else {
  108|   312k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   312k|         using iterator_t = typename ParseInput::iterator_t;
  111|   312k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|   312k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   312k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 312k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   312k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   312k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   312k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   312k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   312k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   312k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   312k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   312k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   312k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   312k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   312k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 312k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   312k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   312k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   312k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   312k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 311k, False: 1.24k]
  ------------------
  143|   311k|            if constexpr( has_apply_void ) {
  144|   311k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|   311k|         }
  156|   312k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 311k, False: 1.32k]
  ------------------
  157|   311k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   311k|         }
  159|  1.32k|         else {
  160|  1.32k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.32k|         }
  162|   312k|         (void)m( result );
  163|   312k|         return result;
  164|   312k|      }
  165|   312k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   312k|      {
   73|   312k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   312k|         else {
   84|   312k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   312k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   312k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   312k|      {
   44|   312k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   312k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   312k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   312k|      else {
  108|   312k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   312k|         using iterator_t = typename ParseInput::iterator_t;
  111|   312k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   312k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   312k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   312k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   312k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   312k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   312k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   312k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   312k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   312k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   312k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   312k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   312k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   312k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   312k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   312k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   312k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   312k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 311k, False: 951]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   311k|            else if constexpr( has_apply0_bool ) {
  153|   311k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   311k|            }
  155|   311k|         }
  156|   312k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 311k, False: 951]
  ------------------
  157|   311k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   311k|         }
  159|    951|         else {
  160|    951|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    951|         }
  162|   312k|         (void)m( result );
  163|   312k|         return result;
  164|   312k|      }
  165|   312k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   312k|      {
   73|   312k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   312k|         else {
   84|   312k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   312k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   312k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   312k|      {
   59|   312k|         return Rule::match( in );
   60|   312k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   311k|   {
  104|   311k|      if constexpr( !Control< Rule >::enable ) {
  105|   311k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   311k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   311k|      {
   44|   311k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   311k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   311k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   311k|      else {
  108|   311k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   311k|         using iterator_t = typename ParseInput::iterator_t;
  111|   311k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   311k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   311k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   311k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   311k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   311k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   311k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   311k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   311k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   311k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   311k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   311k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   311k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   311k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   311k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   311k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   311k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   311k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 311k, False: 291]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   311k|            else if constexpr( has_apply0_bool ) {
  153|   311k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   311k|            }
  155|   311k|         }
  156|   311k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 311k, False: 291]
  ------------------
  157|   311k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   311k|         }
  159|    291|         else {
  160|    291|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    291|         }
  162|   311k|         (void)m( result );
  163|   311k|         return result;
  164|   311k|      }
  165|   311k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   311k|      {
   73|   311k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   311k|         else {
   84|   311k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   311k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   311k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   311k|      {
   44|   311k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   311k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  17.0M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  17.0M|      else {
  108|  17.0M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  17.0M|         using iterator_t = typename ParseInput::iterator_t;
  111|  17.0M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  17.0M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  17.0M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  17.0M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  17.0M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  17.0M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  17.0M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  17.0M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  17.0M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  17.0M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  17.0M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  17.0M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  17.0M|         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.0M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  17.0M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  17.0M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  17.0M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  17.0M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 311k, False: 16.7M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   311k|            else if constexpr( has_apply0_bool ) {
  153|   311k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   311k|            }
  155|   311k|         }
  156|  17.0M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 311k, False: 16.7M]
  ------------------
  157|   311k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   311k|         }
  159|  16.7M|         else {
  160|  16.7M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.7M|         }
  162|  17.0M|         (void)m( result );
  163|  17.0M|         return result;
  164|  17.0M|      }
  165|  17.0M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  17.0M|      {
   73|  17.0M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  17.0M|         else {
   84|  17.0M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  17.0M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  17.0M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  17.0M|      {
   59|  17.0M|         return Rule::match( in );
   60|  17.0M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  16.7M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.7M|      else {
  108|  16.7M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.7M|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.7M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  16.7M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  16.7M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  16.7M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  16.7M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  16.7M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  16.7M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.7M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.7M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.7M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  16.7M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.7M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.7M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.7M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.7M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.7M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.7M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 16.7M, False: 291]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  16.7M|            else if constexpr( has_apply0_bool ) {
  153|  16.7M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  16.7M|            }
  155|  16.7M|         }
  156|  16.7M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 16.7M, False: 291]
  ------------------
  157|  16.7M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  16.7M|         }
  159|    291|         else {
  160|    291|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    291|         }
  162|  16.7M|         (void)m( result );
  163|  16.7M|         return result;
  164|  16.7M|      }
  165|  16.7M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  16.7M|      {
   73|  16.7M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  16.7M|         else {
   84|  16.7M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.7M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.7M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  16.7M|      {
   44|  16.7M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  16.7M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  16.7M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.7M|      else {
  108|  16.7M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.7M|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.7M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  16.7M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  16.7M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  16.7M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  16.7M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  16.7M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  16.7M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.7M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.7M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.7M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  16.7M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.7M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.7M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.7M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.7M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.7M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.7M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 264k, False: 16.4M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   264k|            else if constexpr( has_apply0_bool ) {
  153|   264k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   264k|            }
  155|   264k|         }
  156|  16.7M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 264k, False: 16.4M]
  ------------------
  157|   264k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   264k|         }
  159|  16.4M|         else {
  160|  16.4M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.4M|         }
  162|  16.7M|         (void)m( result );
  163|  16.7M|         return result;
  164|  16.7M|      }
  165|  16.7M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  16.7M|      {
   73|  16.7M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  16.7M|         else {
   84|  16.7M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.7M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.7M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  16.7M|      {
   44|  16.7M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  16.7M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  16.7M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.7M|      else {
  108|  16.7M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.7M|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.7M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  16.7M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  16.7M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  16.7M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  16.7M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  16.7M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  16.7M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.7M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.7M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.7M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  16.7M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.7M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.7M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.7M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.7M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.7M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.7M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 264k, False: 16.4M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   264k|            else if constexpr( has_apply0_bool ) {
  153|   264k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   264k|            }
  155|   264k|         }
  156|  16.7M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 264k, False: 16.4M]
  ------------------
  157|   264k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   264k|         }
  159|  16.4M|         else {
  160|  16.4M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.4M|         }
  162|  16.7M|         (void)m( result );
  163|  16.7M|         return result;
  164|  16.7M|      }
  165|  16.7M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  16.7M|      {
   73|  16.7M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  16.7M|         else {
   84|  16.7M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.7M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.7M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  16.7M|      {
   59|  16.7M|         return Rule::match( in );
   60|  16.7M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   264k|   {
  104|   264k|      if constexpr( !Control< Rule >::enable ) {
  105|   264k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   264k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   264k|      {
   44|   264k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   264k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   264k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   264k|      else {
  108|   264k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   264k|         using iterator_t = typename ParseInput::iterator_t;
  111|   264k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   264k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   264k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   264k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   264k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   264k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   264k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   264k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   264k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   264k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   264k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   264k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   264k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   264k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   264k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   264k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   264k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   264k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 264k, False: 83]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   264k|            else if constexpr( has_apply0_bool ) {
  153|   264k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   264k|            }
  155|   264k|         }
  156|   264k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 264k, False: 83]
  ------------------
  157|   264k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   264k|         }
  159|     83|         else {
  160|     83|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     83|         }
  162|   264k|         (void)m( result );
  163|   264k|         return result;
  164|   264k|      }
  165|   264k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   264k|      {
   73|   264k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   264k|         else {
   84|   264k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   264k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   264k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   264k|      {
   44|   264k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   264k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   264k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   264k|      else {
  108|   264k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   264k|         using iterator_t = typename ParseInput::iterator_t;
  111|   264k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   264k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   264k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   264k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   264k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   264k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   264k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   264k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   264k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   264k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   264k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   264k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   264k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   264k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   264k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   264k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   264k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   264k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 117k, False: 146k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   117k|            else if constexpr( has_apply0_bool ) {
  153|   117k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   117k|            }
  155|   117k|         }
  156|   264k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 117k, False: 146k]
  ------------------
  157|   117k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   117k|         }
  159|   146k|         else {
  160|   146k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   146k|         }
  162|   264k|         (void)m( result );
  163|   264k|         return result;
  164|   264k|      }
  165|   264k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   264k|      {
   73|   264k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   264k|         else {
   84|   264k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   264k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   264k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   264k|      {
   44|   264k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   264k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   264k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   264k|      else {
  108|   264k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   264k|         using iterator_t = typename ParseInput::iterator_t;
  111|   264k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   264k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   264k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   264k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   264k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   264k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   264k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   264k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   264k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   264k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   264k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   264k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   264k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   264k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   264k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   264k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   264k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   264k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 117k, False: 146k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   117k|            else if constexpr( has_apply0_bool ) {
  153|   117k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   117k|            }
  155|   117k|         }
  156|   264k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 117k, False: 146k]
  ------------------
  157|   117k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   117k|         }
  159|   146k|         else {
  160|   146k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   146k|         }
  162|   264k|         (void)m( result );
  163|   264k|         return result;
  164|   264k|      }
  165|   264k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   264k|      {
   73|   264k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   264k|         else {
   84|   264k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   264k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   264k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   264k|      {
   59|   264k|         return Rule::match( in );
   60|   264k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|   117k|   {
  104|   117k|      if constexpr( !Control< Rule >::enable ) {
  105|   117k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   117k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_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_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   117k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   117k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   117k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   117k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   117k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 117k, False: 27]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   117k|            else if constexpr( has_apply0_bool ) {
  153|   117k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   117k|            }
  155|   117k|         }
  156|   117k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 117k, False: 27]
  ------------------
  157|   117k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   117k|         }
  159|     27|         else {
  160|     27|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     27|         }
  162|   117k|         (void)m( result );
  163|   117k|         return result;
  164|   117k|      }
  165|   117k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|   117k|      {
   73|   117k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_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_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   235k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   235k|      else {
  108|   235k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   235k|         using iterator_t = typename ParseInput::iterator_t;
  111|   235k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   235k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   235k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   235k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   235k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   235k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   235k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   235k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   235k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   235k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   235k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   235k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   235k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   235k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   235k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   235k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   235k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   235k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 235k, False: 27]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   235k|            else if constexpr( has_apply0_bool ) {
  153|   235k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   235k|            }
  155|   235k|         }
  156|   235k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 235k, False: 27]
  ------------------
  157|   235k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   235k|         }
  159|     27|         else {
  160|     27|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     27|         }
  162|   235k|         (void)m( result );
  163|   235k|         return result;
  164|   235k|      }
  165|   235k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   235k|      {
   73|   235k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   235k|         else {
   84|   235k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   235k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   235k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   235k|      {
   59|   235k|         return Rule::match( in );
   60|   235k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   146k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   146k|      else {
  108|   146k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   146k|         using iterator_t = typename ParseInput::iterator_t;
  111|   146k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   146k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   146k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   146k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   146k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   146k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   146k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   146k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   146k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   146k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   146k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   146k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   146k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   146k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   146k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   146k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   146k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   146k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.4k, False: 106k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  39.4k|            else if constexpr( has_apply0_bool ) {
  153|  39.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.4k|            }
  155|  39.4k|         }
  156|   146k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.4k, False: 106k]
  ------------------
  157|  39.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.4k|         }
  159|   106k|         else {
  160|   106k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   106k|         }
  162|   146k|         (void)m( result );
  163|   146k|         return result;
  164|   146k|      }
  165|   146k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   146k|      {
   73|   146k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   146k|         else {
   84|   146k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   146k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   146k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   146k|      {
   44|   146k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   146k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   191k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   191k|      else {
  108|   191k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   191k|         using iterator_t = typename ParseInput::iterator_t;
  111|   191k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   191k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   191k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   191k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   191k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   191k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   191k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   191k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   191k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   191k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   191k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   191k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   191k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   191k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   191k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   191k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   191k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   191k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 47.6k, False: 143k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  47.6k|            else if constexpr( has_apply0_bool ) {
  153|  47.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  47.6k|            }
  155|  47.6k|         }
  156|   191k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 47.6k, False: 143k]
  ------------------
  157|  47.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  47.6k|         }
  159|   143k|         else {
  160|   143k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   143k|         }
  162|   191k|         (void)m( result );
  163|   191k|         return result;
  164|   191k|      }
  165|   191k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   191k|      {
   73|   191k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   191k|         else {
   84|   191k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   191k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   191k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   191k|      {
   59|   191k|         return Rule::match( in );
   60|   191k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  39.4k|   {
  104|  39.4k|      if constexpr( !Control< Rule >::enable ) {
  105|  39.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  39.4k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  39.4k|      {
   44|  39.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  39.4k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  39.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  39.4k|      else {
  108|  39.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  39.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  39.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  39.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  39.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  39.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  39.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  39.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  39.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  39.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  39.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  39.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  39.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  39.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  39.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|  39.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  39.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  39.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  39.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  39.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.4k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  39.4k|            else if constexpr( has_apply0_bool ) {
  153|  39.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.4k|            }
  155|  39.4k|         }
  156|  39.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.4k, False: 0]
  ------------------
  157|  39.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.4k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  39.4k|         (void)m( result );
  163|  39.4k|         return result;
  164|  39.4k|      }
  165|  39.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  39.4k|      {
   73|  39.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  39.4k|         else {
   84|  39.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  39.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  39.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  39.4k|      {
   44|  39.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  39.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   106k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   106k|      else {
  108|   106k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   106k|         using iterator_t = typename ParseInput::iterator_t;
  111|   106k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   106k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   106k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   106k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   106k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   106k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   106k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   106k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   106k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   106k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   106k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   106k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   106k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   106k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   106k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   106k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   106k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   106k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 102k, False: 4.62k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   102k|            else if constexpr( has_apply0_bool ) {
  153|   102k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   102k|            }
  155|   102k|         }
  156|   106k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 102k, False: 4.62k]
  ------------------
  157|   102k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   102k|         }
  159|  4.62k|         else {
  160|  4.62k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.62k|         }
  162|   106k|         (void)m( result );
  163|   106k|         return result;
  164|   106k|      }
  165|   106k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   106k|      {
   73|   106k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   106k|         else {
   84|   106k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   106k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   106k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   106k|      {
   59|   106k|         return Rule::match( in );
   60|   106k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.62k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.62k|      else {
  108|  4.62k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.62k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.62k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.62k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.62k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.62k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.62k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.62k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.62k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.62k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.62k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.62k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.62k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.62k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.62k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.62k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.62k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.62k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.62k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.56k, False: 56]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.56k|            else if constexpr( has_apply0_bool ) {
  153|  4.56k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.56k|            }
  155|  4.56k|         }
  156|  4.62k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.56k, False: 56]
  ------------------
  157|  4.56k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.56k|         }
  159|     56|         else {
  160|     56|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     56|         }
  162|  4.62k|         (void)m( result );
  163|  4.62k|         return result;
  164|  4.62k|      }
  165|  4.62k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  4.62k|      {
   73|  4.62k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.62k|         else {
   84|  4.62k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.62k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.62k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.62k|      {
   59|  4.62k|         return Rule::match( in );
   60|  4.62k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  16.4M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.4M|      else {
  108|  16.4M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.4M|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.4M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  16.4M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  16.4M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  16.4M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  16.4M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  16.4M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  16.4M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.4M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.4M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.4M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  16.4M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.4M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.4M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  16.4M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.4M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.4M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.4M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.4M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 16.4M, False: 208]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  16.4M|            else if constexpr( has_apply0_bool ) {
  153|  16.4M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  16.4M|            }
  155|  16.4M|         }
  156|  16.4M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 16.4M, False: 208]
  ------------------
  157|  16.4M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  16.4M|         }
  159|    208|         else {
  160|    208|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    208|         }
  162|  16.4M|         (void)m( result );
  163|  16.4M|         return result;
  164|  16.4M|      }
  165|  16.4M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  16.4M|      {
   73|  16.4M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  16.4M|         else {
   84|  16.4M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.4M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.4M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  16.4M|      {
   59|  16.4M|         return Rule::match( in );
   60|  16.4M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  35.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  35.1k|      else {
  108|  35.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  35.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  35.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  35.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  35.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  35.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  35.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  35.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  35.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  35.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  35.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  35.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  35.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  35.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  35.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|  35.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  35.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  35.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  35.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  35.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.38k, False: 31.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.38k|            else if constexpr( has_apply0_bool ) {
  153|  3.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.38k|            }
  155|  3.38k|         }
  156|  35.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.38k, False: 31.7k]
  ------------------
  157|  3.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.38k|         }
  159|  31.7k|         else {
  160|  31.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  31.7k|         }
  162|  35.1k|         (void)m( result );
  163|  35.1k|         return result;
  164|  35.1k|      }
  165|  35.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  35.1k|      {
   73|  35.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  35.1k|         else {
   84|  35.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  35.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  35.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  35.1k|      {
   44|  35.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  35.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  35.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  35.1k|      else {
  108|  35.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  35.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  35.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  35.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  35.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  35.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  35.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  35.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  35.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  35.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  35.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  35.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  35.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  35.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  35.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|  35.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  35.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  35.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  35.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  35.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.38k, False: 31.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.38k|            else if constexpr( has_apply0_bool ) {
  153|  3.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.38k|            }
  155|  3.38k|         }
  156|  35.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.38k, False: 31.7k]
  ------------------
  157|  3.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.38k|         }
  159|  31.7k|         else {
  160|  31.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  31.7k|         }
  162|  35.1k|         (void)m( result );
  163|  35.1k|         return result;
  164|  35.1k|      }
  165|  35.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_8str_hashENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  35.1k|      {
   73|  35.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  35.1k|         else {
   84|  35.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  35.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  35.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_8str_hashENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  35.1k|      {
   44|  35.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  35.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8str_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  35.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  35.1k|      else {
  108|  35.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  35.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  35.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  35.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  35.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 35.1k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  35.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  35.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  35.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  35.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  35.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  35.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  35.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  35.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  35.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  35.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|  35.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 35.1k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  35.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  35.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  35.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  35.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.13k, False: 30.9k]
  ------------------
  143|  4.13k|            if constexpr( has_apply_void ) {
  144|  4.13k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  4.13k|         }
  156|  35.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.12k, False: 31.0k]
  ------------------
  157|  4.12k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.12k|         }
  159|  31.0k|         else {
  160|  31.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  31.0k|         }
  162|  35.1k|         (void)m( result );
  163|  35.1k|         return result;
  164|  35.1k|      }
  165|  35.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser8str_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  35.1k|      {
   73|  35.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  35.1k|         else {
   84|  35.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  35.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  35.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser8str_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  35.1k|      {
   59|  35.1k|         return Rule::match( in );
   60|  35.1k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  11.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  11.8k|      else {
  108|  11.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  11.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  11.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  11.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  11.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  11.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  11.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  11.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.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|  11.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  11.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.97k, False: 1.87k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  9.97k|            else if constexpr( has_apply0_bool ) {
  153|  9.97k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.97k|            }
  155|  9.97k|         }
  156|  11.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.97k, False: 1.87k]
  ------------------
  157|  9.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.97k|         }
  159|  1.87k|         else {
  160|  1.87k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.87k|         }
  162|  11.8k|         (void)m( result );
  163|  11.8k|         return result;
  164|  11.8k|      }
  165|  11.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  11.8k|      {
   73|  11.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  11.8k|         else {
   84|  11.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  11.8k|      {
   44|  11.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  11.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  11.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  11.8k|      else {
  108|  11.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  11.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  11.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  11.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  11.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  11.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  11.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  11.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.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|  11.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  11.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.97k, False: 1.87k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  9.97k|            else if constexpr( has_apply0_bool ) {
  153|  9.97k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.97k|            }
  155|  9.97k|         }
  156|  11.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.97k, False: 1.87k]
  ------------------
  157|  9.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.97k|         }
  159|  1.87k|         else {
  160|  1.87k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.87k|         }
  162|  11.8k|         (void)m( result );
  163|  11.8k|         return result;
  164|  11.8k|      }
  165|  11.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  11.8k|      {
   73|  11.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  11.8k|         else {
   84|  11.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  11.8k|      {
   59|  11.8k|         return Rule::match( in );
   60|  11.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  20.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  20.7k|      else {
  108|  20.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  20.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  20.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  20.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  20.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  20.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  20.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  20.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  20.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  20.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  20.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  20.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  20.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  20.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  20.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|  20.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  20.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  20.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  20.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  20.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.36k, False: 15.3k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.36k|            else if constexpr( has_apply0_bool ) {
  153|  5.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.36k|            }
  155|  5.36k|         }
  156|  20.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.36k, False: 15.3k]
  ------------------
  157|  5.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.36k|         }
  159|  15.3k|         else {
  160|  15.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  15.3k|         }
  162|  20.7k|         (void)m( result );
  163|  20.7k|         return result;
  164|  20.7k|      }
  165|  20.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  20.7k|      {
   73|  20.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  20.7k|         else {
   84|  20.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  20.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  20.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  20.7k|      {
   59|  20.7k|         return Rule::match( in );
   60|  20.7k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.10k|      else {
  108|  4.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.10k|         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.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.38k, False: 726]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.38k|            else if constexpr( has_apply0_bool ) {
  153|  3.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.38k|            }
  155|  3.38k|         }
  156|  4.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.38k, False: 726]
  ------------------
  157|  3.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.38k|         }
  159|    726|         else {
  160|    726|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    726|         }
  162|  4.10k|         (void)m( result );
  163|  4.10k|         return result;
  164|  4.10k|      }
  165|  4.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.10k|      {
   73|  4.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.10k|         else {
   84|  4.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.10k|      {
   44|  4.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.10k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.10k|      else {
  108|  4.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.10k|         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.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.52k, False: 1.58k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.52k|            else if constexpr( has_apply0_bool ) {
  153|  2.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.52k|            }
  155|  2.52k|         }
  156|  4.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.52k, False: 1.58k]
  ------------------
  157|  2.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.52k|         }
  159|  1.58k|         else {
  160|  1.58k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.58k|         }
  162|  4.10k|         (void)m( result );
  163|  4.10k|         return result;
  164|  4.10k|      }
  165|  4.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.10k|      {
   73|  4.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.10k|         else {
   84|  4.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.10k|      {
   44|  4.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.10k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.10k|      else {
  108|  4.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.10k|         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.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.10k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.10k|            else if constexpr( has_apply0_bool ) {
  153|  4.10k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.10k|            }
  155|  4.10k|         }
  156|  4.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.10k, False: 0]
  ------------------
  157|  4.10k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.10k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.10k|         (void)m( result );
  163|  4.10k|         return result;
  164|  4.10k|      }
  165|  4.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.10k|      {
   73|  4.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.10k|         else {
   84|  4.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.10k|      {
   44|  4.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.10k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  4.10k|   {
  104|  4.10k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.10k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.10k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.10k|      {
   44|  4.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.10k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.10k|      else {
  108|  4.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  4.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.10k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.10k|         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.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.10k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.44k, False: 2.66k]
  ------------------
  143|  1.44k|            if constexpr( has_apply_void ) {
  144|  1.44k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.44k|         }
  156|  4.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.44k, False: 2.66k]
  ------------------
  157|  1.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.44k|         }
  159|  2.66k|         else {
  160|  2.66k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.66k|         }
  162|  4.10k|         (void)m( result );
  163|  4.10k|         return result;
  164|  4.10k|      }
  165|  4.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.10k|      {
   73|  4.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.10k|         else {
   84|  4.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.10k|      {
   44|  4.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.10k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.10k|      else {
  108|  4.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.10k|         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.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 212, False: 3.89k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    212|            else if constexpr( has_apply0_bool ) {
  153|    212|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    212|            }
  155|    212|         }
  156|  4.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 212, False: 3.89k]
  ------------------
  157|    212|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    212|         }
  159|  3.89k|         else {
  160|  3.89k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.89k|         }
  162|  4.10k|         (void)m( result );
  163|  4.10k|         return result;
  164|  4.10k|      }
  165|  4.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.10k|      {
   73|  4.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.10k|         else {
   84|  4.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.10k|      {
   59|  4.10k|         return Rule::match( in );
   60|  4.10k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.89k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.89k|      else {
  108|  3.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 284, False: 3.61k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    284|            else if constexpr( has_apply0_bool ) {
  153|    284|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    284|            }
  155|    284|         }
  156|  3.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 284, False: 3.61k]
  ------------------
  157|    284|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    284|         }
  159|  3.61k|         else {
  160|  3.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.61k|         }
  162|  3.89k|         (void)m( result );
  163|  3.89k|         return result;
  164|  3.89k|      }
  165|  3.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.89k|      {
   73|  3.89k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.89k|         else {
   84|  3.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.89k|      {
   59|  3.89k|         return Rule::match( in );
   60|  3.89k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.61k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.61k|      else {
  108|  3.61k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.61k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.61k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.61k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.61k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.61k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.61k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.61k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.61k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.61k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.61k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.61k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.61k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.61k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.61k|         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.61k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.61k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.61k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.61k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.61k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 207, False: 3.40k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    207|            else if constexpr( has_apply0_bool ) {
  153|    207|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    207|            }
  155|    207|         }
  156|  3.61k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 207, False: 3.40k]
  ------------------
  157|    207|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    207|         }
  159|  3.40k|         else {
  160|  3.40k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.40k|         }
  162|  3.61k|         (void)m( result );
  163|  3.61k|         return result;
  164|  3.61k|      }
  165|  3.61k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.61k|      {
   73|  3.61k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.61k|         else {
   84|  3.61k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.61k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.61k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.61k|      {
   59|  3.61k|         return Rule::match( in );
   60|  3.61k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.40k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.40k|      else {
  108|  3.40k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.40k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.40k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.40k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.40k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.40k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.40k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.40k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.40k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.40k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.40k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.40k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.40k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.40k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.40k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.40k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.40k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.40k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.40k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 3.21k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    194|            else if constexpr( has_apply0_bool ) {
  153|    194|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    194|            }
  155|    194|         }
  156|  3.40k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 3.21k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  3.21k|         else {
  160|  3.21k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.21k|         }
  162|  3.40k|         (void)m( result );
  163|  3.40k|         return result;
  164|  3.40k|      }
  165|  3.40k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.40k|      {
   73|  3.40k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.40k|         else {
   84|  3.40k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.40k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.40k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.40k|      {
   59|  3.40k|         return Rule::match( in );
   60|  3.40k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.21k|      else {
  108|  3.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 329, False: 2.88k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    329|            else if constexpr( has_apply0_bool ) {
  153|    329|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    329|            }
  155|    329|         }
  156|  3.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 329, False: 2.88k]
  ------------------
  157|    329|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    329|         }
  159|  2.88k|         else {
  160|  2.88k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.88k|         }
  162|  3.21k|         (void)m( result );
  163|  3.21k|         return result;
  164|  3.21k|      }
  165|  3.21k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.21k|      {
   73|  3.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.21k|         else {
   84|  3.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.21k|      {
   59|  3.21k|         return Rule::match( in );
   60|  3.21k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.88k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.88k|      else {
  108|  2.88k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.88k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.88k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.88k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.88k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.88k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.88k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.88k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.88k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.88k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.88k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.88k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.88k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.88k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.88k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.88k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.88k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.88k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.88k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 219, False: 2.66k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    219|            else if constexpr( has_apply0_bool ) {
  153|    219|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    219|            }
  155|    219|         }
  156|  2.88k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 219, False: 2.66k]
  ------------------
  157|    219|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    219|         }
  159|  2.66k|         else {
  160|  2.66k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.66k|         }
  162|  2.88k|         (void)m( result );
  163|  2.88k|         return result;
  164|  2.88k|      }
  165|  2.88k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.88k|      {
   73|  2.88k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.88k|         else {
   84|  2.88k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.88k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.88k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.88k|      {
   59|  2.88k|         return Rule::match( in );
   60|  2.88k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.10k|      else {
  108|  4.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.10k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.10k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.10k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.10k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.10k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.10k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.10k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.10k|         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.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.74k, False: 1.36k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.74k|            else if constexpr( has_apply0_bool ) {
  153|  2.74k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.74k|            }
  155|  2.74k|         }
  156|  4.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.74k, False: 1.36k]
  ------------------
  157|  2.74k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.74k|         }
  159|  1.36k|         else {
  160|  1.36k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.36k|         }
  162|  4.10k|         (void)m( result );
  163|  4.10k|         return result;
  164|  4.10k|      }
  165|  4.10k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  4.10k|      {
   73|  4.10k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.10k|         else {
   84|  4.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.10k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.10k|      {
   59|  4.10k|         return Rule::match( in );
   60|  4.10k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.39k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.39k|      else {
  108|  5.39k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.39k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.39k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.39k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.39k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.39k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.39k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.39k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.39k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.39k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.39k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.39k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.39k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.39k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.39k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.39k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.39k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.39k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.39k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.39k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.39k|            else if constexpr( has_apply0_bool ) {
  153|  5.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.39k|            }
  155|  5.39k|         }
  156|  5.39k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.39k, False: 0]
  ------------------
  157|  5.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.39k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  5.39k|         (void)m( result );
  163|  5.39k|         return result;
  164|  5.39k|      }
  165|  5.39k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  5.39k|      {
   73|  5.39k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.39k|         else {
   84|  5.39k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.39k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.39k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.39k|      {
   44|  5.39k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.39k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.74k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.74k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.74k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.74k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.74k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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.65k, False: 88]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.65k|            else if constexpr( has_apply0_bool ) {
  153|  2.65k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.65k|            }
  155|  2.65k|         }
  156|  2.74k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.65k, False: 88]
  ------------------
  157|  2.65k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.65k|         }
  159|     88|         else {
  160|     88|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     88|         }
  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_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_modeE0ETtTpTyENS5_12hash_actionsETtTpTyENS0_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_modeE0ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.67k|   {
  104|  2.67k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.67k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.67k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.67k|      {
   44|  2.67k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.67k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.27k|   {
  104|  6.27k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.27k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  6.27k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.27k|      {
   44|  6.27k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.27k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.65k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.65k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.65k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.65k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.65k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 2.52k, False: 126]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.52k|            else if constexpr( has_apply0_bool ) {
  153|  2.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.52k|            }
  155|  2.52k|         }
  156|  2.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.52k, False: 126]
  ------------------
  157|  2.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.52k|         }
  159|    126|         else {
  160|    126|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    126|         }
  162|  2.65k|         (void)m( result );
  163|  2.65k|         return result;
  164|  2.65k|      }
  165|  2.65k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.65k|      {
   73|  2.65k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.65k|      {
   59|  2.65k|         return Rule::match( in );
   60|  2.65k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.74k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.74k|      else {
  108|  8.74k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.74k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.74k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  8.74k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.74k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 8.74k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.74k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.74k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.74k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.74k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.74k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.74k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.74k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.74k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.74k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.74k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 8.74k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.74k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.74k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.74k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.74k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.19k, False: 1.54k]
  ------------------
  143|  7.19k|            if constexpr( has_apply_void ) {
  144|  7.19k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  7.19k|         }
  156|  8.74k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.12k, False: 1.61k]
  ------------------
  157|  7.12k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.12k|         }
  159|  1.61k|         else {
  160|  1.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.61k|         }
  162|  8.74k|         (void)m( result );
  163|  8.74k|         return result;
  164|  8.74k|      }
  165|  8.74k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  8.74k|      {
   73|  8.74k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.74k|         else {
   84|  8.74k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.74k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.74k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.74k|      {
   44|  8.74k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.74k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.74k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.74k|      else {
  108|  8.74k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.74k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.74k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.74k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.74k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.74k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.74k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.74k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.74k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.74k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.74k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.74k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.74k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.74k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.74k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.74k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.74k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.74k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.74k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.50k, False: 1.23k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.50k|            else if constexpr( has_apply0_bool ) {
  153|  7.50k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.50k|            }
  155|  7.50k|         }
  156|  8.74k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.50k, False: 1.23k]
  ------------------
  157|  7.50k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.50k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|  8.74k|         (void)m( result );
  163|  8.74k|         return result;
  164|  8.74k|      }
  165|  8.74k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  8.74k|      {
   73|  8.74k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.74k|         else {
   84|  8.74k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.74k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.74k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  8.74k|      {
   59|  8.74k|         return Rule::match( in );
   60|  8.74k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  7.50k|   {
  104|  7.50k|      if constexpr( !Control< Rule >::enable ) {
  105|  7.50k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  7.50k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.50k|      {
   44|  7.50k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.50k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  7.50k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.50k|      else {
  108|  7.50k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.50k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.50k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  7.50k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.50k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.50k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.50k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.50k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  7.50k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.50k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.50k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.50k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  7.50k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.50k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.50k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.50k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.50k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.50k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.50k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.19k, False: 312]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.19k|            else if constexpr( has_apply0_bool ) {
  153|  7.19k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.19k|            }
  155|  7.19k|         }
  156|  7.50k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.19k, False: 312]
  ------------------
  157|  7.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.19k|         }
  159|    312|         else {
  160|    312|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    312|         }
  162|  7.50k|         (void)m( result );
  163|  7.50k|         return result;
  164|  7.50k|      }
  165|  7.50k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  7.50k|      {
   73|  7.50k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  7.50k|         else {
   84|  7.50k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.50k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.50k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.50k|      {
   44|  7.50k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.50k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.87M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.87M|      else {
  108|  9.87M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.87M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.87M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.87M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.87M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.87M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.87M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.87M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.87M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.87M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.87M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.87M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.87M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.87M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.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|  9.87M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.87M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.87M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.87M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.87M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.19k, False: 9.86M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.19k|            else if constexpr( has_apply0_bool ) {
  153|  7.19k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.19k|            }
  155|  7.19k|         }
  156|  9.87M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.19k, False: 9.86M]
  ------------------
  157|  7.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.19k|         }
  159|  9.86M|         else {
  160|  9.86M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.86M|         }
  162|  9.87M|         (void)m( result );
  163|  9.87M|         return result;
  164|  9.87M|      }
  165|  9.87M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  9.87M|      {
   73|  9.87M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.87M|         else {
   84|  9.87M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.87M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.87M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.87M|      {
   59|  9.87M|         return Rule::match( in );
   60|  9.87M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.86M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.86M|      else {
  108|  9.86M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.86M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.86M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.86M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.86M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.86M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.86M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.86M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.86M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.86M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.86M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.86M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.86M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.86M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.86M|         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.86M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.86M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.86M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.86M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.86M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.86M, False: 312]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  9.86M|            else if constexpr( has_apply0_bool ) {
  153|  9.86M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.86M|            }
  155|  9.86M|         }
  156|  9.86M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.86M, False: 312]
  ------------------
  157|  9.86M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.86M|         }
  159|    312|         else {
  160|    312|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    312|         }
  162|  9.86M|         (void)m( result );
  163|  9.86M|         return result;
  164|  9.86M|      }
  165|  9.86M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.86M|      {
   73|  9.86M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.86M|         else {
   84|  9.86M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.86M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.86M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.86M|      {
   44|  9.86M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.86M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.86M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.86M|      else {
  108|  9.86M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.86M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.86M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.86M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.86M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.86M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.86M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.86M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.86M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.86M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.86M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.86M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.86M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.86M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.86M|         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.86M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.86M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.86M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.86M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.86M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 143k, False: 9.71M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   143k|            else if constexpr( has_apply0_bool ) {
  153|   143k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   143k|            }
  155|   143k|         }
  156|  9.86M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 143k, False: 9.71M]
  ------------------
  157|   143k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   143k|         }
  159|  9.71M|         else {
  160|  9.71M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.71M|         }
  162|  9.86M|         (void)m( result );
  163|  9.86M|         return result;
  164|  9.86M|      }
  165|  9.86M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.86M|      {
   73|  9.86M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.86M|         else {
   84|  9.86M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.86M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.86M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.86M|      {
   44|  9.86M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.86M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.86M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.86M|      else {
  108|  9.86M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.86M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.86M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.86M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.86M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.86M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.86M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.86M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.86M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.86M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.86M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.86M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.86M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.86M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.86M|         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.86M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.86M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.86M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.86M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.86M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 143k, False: 9.71M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   143k|            else if constexpr( has_apply0_bool ) {
  153|   143k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   143k|            }
  155|   143k|         }
  156|  9.86M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 143k, False: 9.71M]
  ------------------
  157|   143k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   143k|         }
  159|  9.71M|         else {
  160|  9.71M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.71M|         }
  162|  9.86M|         (void)m( result );
  163|  9.86M|         return result;
  164|  9.86M|      }
  165|  9.86M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  9.86M|      {
   73|  9.86M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.86M|         else {
   84|  9.86M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.86M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.86M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.86M|      {
   59|  9.86M|         return Rule::match( in );
   60|  9.86M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   143k|   {
  104|   143k|      if constexpr( !Control< Rule >::enable ) {
  105|   143k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   143k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   143k|      {
   44|   143k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   143k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   143k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   143k|      else {
  108|   143k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   143k|         using iterator_t = typename ParseInput::iterator_t;
  111|   143k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   143k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   143k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   143k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   143k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   143k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   143k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   143k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   143k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   143k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   143k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   143k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   143k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   143k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   143k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   143k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   143k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   143k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 143k, False: 102]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   143k|            else if constexpr( has_apply0_bool ) {
  153|   143k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   143k|            }
  155|   143k|         }
  156|   143k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 143k, False: 102]
  ------------------
  157|   143k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   143k|         }
  159|    102|         else {
  160|    102|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    102|         }
  162|   143k|         (void)m( result );
  163|   143k|         return result;
  164|   143k|      }
  165|   143k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   143k|      {
   73|   143k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   143k|         else {
   84|   143k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   143k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   143k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   143k|      {
   44|   143k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   143k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   143k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   143k|      else {
  108|   143k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   143k|         using iterator_t = typename ParseInput::iterator_t;
  111|   143k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   143k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   143k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   143k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   143k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   143k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   143k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   143k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   143k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   143k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   143k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   143k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   143k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   143k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   143k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   143k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   143k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   143k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 48.0k, False: 95.5k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  48.0k|            else if constexpr( has_apply0_bool ) {
  153|  48.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  48.0k|            }
  155|  48.0k|         }
  156|   143k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 48.0k, False: 95.5k]
  ------------------
  157|  48.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  48.0k|         }
  159|  95.5k|         else {
  160|  95.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  95.5k|         }
  162|   143k|         (void)m( result );
  163|   143k|         return result;
  164|   143k|      }
  165|   143k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   143k|      {
   73|   143k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   143k|         else {
   84|   143k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   143k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   143k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   143k|      {
   44|   143k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   143k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   143k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   143k|      else {
  108|   143k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   143k|         using iterator_t = typename ParseInput::iterator_t;
  111|   143k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   143k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   143k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   143k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   143k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   143k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   143k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   143k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   143k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   143k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   143k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   143k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   143k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   143k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   143k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   143k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   143k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   143k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 48.1k, False: 95.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  48.1k|            else if constexpr( has_apply0_bool ) {
  153|  48.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  48.1k|            }
  155|  48.1k|         }
  156|   143k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 48.1k, False: 95.4k]
  ------------------
  157|  48.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  48.1k|         }
  159|  95.4k|         else {
  160|  95.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  95.4k|         }
  162|   143k|         (void)m( result );
  163|   143k|         return result;
  164|   143k|      }
  165|   143k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   143k|      {
   73|   143k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   143k|         else {
   84|   143k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   143k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   143k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   143k|      {
   59|   143k|         return Rule::match( in );
   60|   143k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  48.1k|   {
  104|  48.1k|      if constexpr( !Control< Rule >::enable ) {
  105|  48.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  48.1k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  48.1k|      {
   44|  48.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  48.1k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  48.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  48.1k|      else {
  108|  48.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  48.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  48.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  48.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  48.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  48.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  48.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  48.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  48.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  48.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  48.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  48.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  48.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  48.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  48.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|  48.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  48.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  48.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  48.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  48.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 48.0k, False: 41]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  48.0k|            else if constexpr( has_apply0_bool ) {
  153|  48.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  48.0k|            }
  155|  48.0k|         }
  156|  48.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 48.0k, False: 41]
  ------------------
  157|  48.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  48.0k|         }
  159|     41|         else {
  160|     41|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     41|         }
  162|  48.1k|         (void)m( result );
  163|  48.1k|         return result;
  164|  48.1k|      }
  165|  48.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  48.1k|      {
   73|  48.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  48.1k|         else {
   84|  48.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  48.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  48.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  48.1k|      {
   44|  48.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  48.1k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  96.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  96.1k|      else {
  108|  96.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  96.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  96.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  96.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  96.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  96.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  96.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  96.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  96.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  96.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  96.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  96.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  96.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  96.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  96.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|  96.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  96.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  96.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  96.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  96.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 96.1k, False: 41]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  96.1k|            else if constexpr( has_apply0_bool ) {
  153|  96.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  96.1k|            }
  155|  96.1k|         }
  156|  96.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 96.1k, False: 41]
  ------------------
  157|  96.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  96.1k|         }
  159|     41|         else {
  160|     41|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     41|         }
  162|  96.1k|         (void)m( result );
  163|  96.1k|         return result;
  164|  96.1k|      }
  165|  96.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  96.1k|      {
   73|  96.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  96.1k|         else {
   84|  96.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  96.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  96.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  96.1k|      {
   59|  96.1k|         return Rule::match( in );
   60|  96.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  95.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  95.4k|      else {
  108|  95.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  95.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  95.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  95.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  95.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  95.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  95.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  95.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  95.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  95.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  95.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  95.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  95.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  95.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  95.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|  95.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  95.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  95.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  95.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  95.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 48.0k, False: 47.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  48.0k|            else if constexpr( has_apply0_bool ) {
  153|  48.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  48.0k|            }
  155|  48.0k|         }
  156|  95.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 48.0k, False: 47.4k]
  ------------------
  157|  48.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  48.0k|         }
  159|  47.4k|         else {
  160|  47.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  47.4k|         }
  162|  95.4k|         (void)m( result );
  163|  95.4k|         return result;
  164|  95.4k|      }
  165|  95.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  95.4k|      {
   73|  95.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  95.4k|         else {
   84|  95.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  95.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  95.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  95.4k|      {
   44|  95.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  95.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   148k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   148k|      else {
  108|   148k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   148k|         using iterator_t = typename ParseInput::iterator_t;
  111|   148k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   148k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   148k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   148k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   148k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   148k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   148k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   148k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   148k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   148k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   148k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   148k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   148k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   148k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   148k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   148k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   148k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   148k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 57.6k, False: 91.1k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  57.6k|            else if constexpr( has_apply0_bool ) {
  153|  57.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  57.6k|            }
  155|  57.6k|         }
  156|   148k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 57.6k, False: 91.1k]
  ------------------
  157|  57.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  57.6k|         }
  159|  91.1k|         else {
  160|  91.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  91.1k|         }
  162|   148k|         (void)m( result );
  163|   148k|         return result;
  164|   148k|      }
  165|   148k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   148k|      {
   73|   148k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   148k|         else {
   84|   148k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   148k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   148k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   148k|      {
   59|   148k|         return Rule::match( in );
   60|   148k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  48.0k|   {
  104|  48.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  48.0k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  48.0k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  48.0k|      {
   44|  48.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  48.0k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  48.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  48.0k|      else {
  108|  48.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  48.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  48.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  48.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  48.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  48.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  48.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  48.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  48.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  48.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  48.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  48.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  48.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  48.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  48.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|  48.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  48.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  48.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  48.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  48.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 48.0k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  48.0k|            else if constexpr( has_apply0_bool ) {
  153|  48.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  48.0k|            }
  155|  48.0k|         }
  156|  48.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 48.0k, False: 0]
  ------------------
  157|  48.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  48.0k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  48.0k|         (void)m( result );
  163|  48.0k|         return result;
  164|  48.0k|      }
  165|  48.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  48.0k|      {
   73|  48.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  48.0k|         else {
   84|  48.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  48.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  48.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  48.0k|      {
   44|  48.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  48.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  47.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  47.4k|      else {
  108|  47.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  47.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  47.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  47.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  47.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  47.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  47.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  47.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  47.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  47.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  47.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  47.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  47.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  47.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  47.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|  47.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  47.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  47.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  47.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  47.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 46.5k, False: 897]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  46.5k|            else if constexpr( has_apply0_bool ) {
  153|  46.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  46.5k|            }
  155|  46.5k|         }
  156|  47.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 46.5k, False: 897]
  ------------------
  157|  46.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  46.5k|         }
  159|    897|         else {
  160|    897|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    897|         }
  162|  47.4k|         (void)m( result );
  163|  47.4k|         return result;
  164|  47.4k|      }
  165|  47.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  47.4k|      {
   73|  47.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  47.4k|         else {
   84|  47.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  47.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  47.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  47.4k|      {
   59|  47.4k|         return Rule::match( in );
   60|  47.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    897|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    897|      else {
  108|    897|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    897|         using iterator_t = typename ParseInput::iterator_t;
  111|    897|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    897|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    897|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    897|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    897|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    897|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    897|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    897|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    897|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    897|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    897|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    897|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    897|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    897|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    897|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    897|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    897|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    897|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 836, False: 61]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    836|            else if constexpr( has_apply0_bool ) {
  153|    836|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    836|            }
  155|    836|         }
  156|    897|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 836, False: 61]
  ------------------
  157|    836|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    836|         }
  159|     61|         else {
  160|     61|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     61|         }
  162|    897|         (void)m( result );
  163|    897|         return result;
  164|    897|      }
  165|    897|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    897|      {
   73|    897|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    897|         else {
   84|    897|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    897|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    897|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|    897|      {
   59|    897|         return Rule::match( in );
   60|    897|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.71M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.71M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.71M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.71M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.71M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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.71M, False: 210]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  9.71M|            else if constexpr( has_apply0_bool ) {
  153|  9.71M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.71M|            }
  155|  9.71M|         }
  156|  9.71M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.71M, False: 210]
  ------------------
  157|  9.71M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.71M|         }
  159|    210|         else {
  160|    210|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    210|         }
  162|  9.71M|         (void)m( result );
  163|  9.71M|         return result;
  164|  9.71M|      }
  165|  9.71M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.71M|      {
   73|  9.71M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.71M|      {
   59|  9.71M|         return Rule::match( in );
   60|  9.71M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser21parent_hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  31.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  31.3k|      else {
  108|  31.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  31.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  31.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  31.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  31.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  31.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  31.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  31.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.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|  31.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  31.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.90k, False: 28.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.90k|            else if constexpr( has_apply0_bool ) {
  153|  2.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.90k|            }
  155|  2.90k|         }
  156|  31.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.90k, False: 28.4k]
  ------------------
  157|  2.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.90k|         }
  159|  28.4k|         else {
  160|  28.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  28.4k|         }
  162|  31.3k|         (void)m( result );
  163|  31.3k|         return result;
  164|  31.3k|      }
  165|  31.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser21parent_hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  31.3k|      {
   73|  31.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  31.3k|         else {
   84|  31.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  31.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  31.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser21parent_hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  31.3k|      {
   44|  31.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  31.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  31.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  31.3k|      else {
  108|  31.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  31.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  31.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  31.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  31.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  31.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  31.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  31.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.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|  31.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  31.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.90k, False: 28.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.90k|            else if constexpr( has_apply0_bool ) {
  153|  2.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.90k|            }
  155|  2.90k|         }
  156|  31.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.90k, False: 28.4k]
  ------------------
  157|  2.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.90k|         }
  159|  28.4k|         else {
  160|  28.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  28.4k|         }
  162|  31.3k|         (void)m( result );
  163|  31.3k|         return result;
  164|  31.3k|      }
  165|  31.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_15str_parent_hashENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  31.3k|      {
   73|  31.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  31.3k|         else {
   84|  31.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  31.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  31.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_15str_parent_hashENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  31.3k|      {
   44|  31.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  31.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15str_parent_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  31.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  31.3k|      else {
  108|  31.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  31.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  31.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 31.3k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  31.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  31.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  31.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  31.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  31.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.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|  31.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 31.3k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  31.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.55k, False: 27.8k]
  ------------------
  143|  3.55k|            if constexpr( has_apply_void ) {
  144|  3.55k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  3.55k|         }
  156|  31.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.55k, False: 27.8k]
  ------------------
  157|  3.55k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.55k|         }
  159|  27.8k|         else {
  160|  27.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  27.8k|         }
  162|  31.3k|         (void)m( result );
  163|  31.3k|         return result;
  164|  31.3k|      }
  165|  31.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15str_parent_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  31.3k|      {
   73|  31.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  31.3k|         else {
   84|  31.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  31.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  31.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15str_parent_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  31.3k|      {
   59|  31.3k|         return Rule::match( in );
   60|  31.3k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  10.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.7k|      else {
  108|  10.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.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|  10.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.22k, False: 1.53k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  9.22k|            else if constexpr( has_apply0_bool ) {
  153|  9.22k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.22k|            }
  155|  9.22k|         }
  156|  10.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.22k, False: 1.53k]
  ------------------
  157|  9.22k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.22k|         }
  159|  1.53k|         else {
  160|  1.53k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.53k|         }
  162|  10.7k|         (void)m( result );
  163|  10.7k|         return result;
  164|  10.7k|      }
  165|  10.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  10.7k|      {
   73|  10.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.7k|         else {
   84|  10.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  10.7k|      {
   44|  10.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  10.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.7k|      else {
  108|  10.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.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|  10.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.22k, False: 1.53k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  9.22k|            else if constexpr( has_apply0_bool ) {
  153|  9.22k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.22k|            }
  155|  9.22k|         }
  156|  10.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.22k, False: 1.53k]
  ------------------
  157|  9.22k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.22k|         }
  159|  1.53k|         else {
  160|  1.53k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.53k|         }
  162|  10.7k|         (void)m( result );
  163|  10.7k|         return result;
  164|  10.7k|      }
  165|  10.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  10.7k|      {
   73|  10.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.7k|         else {
   84|  10.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  10.7k|      {
   59|  10.7k|         return Rule::match( in );
   60|  10.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  18.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  18.3k|      else {
  108|  18.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  18.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  18.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  18.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  18.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  18.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  18.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  18.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  18.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  18.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  18.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  18.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  18.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  18.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  18.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|  18.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  18.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  18.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  18.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  18.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.53k, False: 13.8k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  18.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.53k, False: 13.8k]
  ------------------
  157|  4.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.53k|         }
  159|  13.8k|         else {
  160|  13.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.8k|         }
  162|  18.3k|         (void)m( result );
  163|  18.3k|         return result;
  164|  18.3k|      }
  165|  18.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  18.3k|      {
   73|  18.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  18.3k|         else {
   84|  18.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  18.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  18.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  18.3k|      {
   59|  18.3k|         return Rule::match( in );
   60|  18.3k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.53k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.53k|      else {
  108|  3.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.90k, False: 631]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.90k|            else if constexpr( has_apply0_bool ) {
  153|  2.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.90k|            }
  155|  2.90k|         }
  156|  3.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.90k, False: 631]
  ------------------
  157|  2.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.90k|         }
  159|    631|         else {
  160|    631|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    631|         }
  162|  3.53k|         (void)m( result );
  163|  3.53k|         return result;
  164|  3.53k|      }
  165|  3.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.53k|      {
   73|  3.53k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.53k|         else {
   84|  3.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.53k|      {
   44|  3.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.53k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.53k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.53k|      else {
  108|  3.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.14k, False: 1.39k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.14k|            else if constexpr( has_apply0_bool ) {
  153|  2.14k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.14k|            }
  155|  2.14k|         }
  156|  3.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.14k, False: 1.39k]
  ------------------
  157|  2.14k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.14k|         }
  159|  1.39k|         else {
  160|  1.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.39k|         }
  162|  3.53k|         (void)m( result );
  163|  3.53k|         return result;
  164|  3.53k|      }
  165|  3.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.53k|      {
   73|  3.53k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.53k|         else {
   84|  3.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.53k|      {
   44|  3.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.53k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.53k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.53k|      else {
  108|  3.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.53k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.53k|            else if constexpr( has_apply0_bool ) {
  153|  3.53k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.53k|            }
  155|  3.53k|         }
  156|  3.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.53k, False: 0]
  ------------------
  157|  3.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.53k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.53k|         (void)m( result );
  163|  3.53k|         return result;
  164|  3.53k|      }
  165|  3.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.53k|      {
   73|  3.53k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.53k|         else {
   84|  3.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.53k|      {
   44|  3.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.53k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.53k|   {
  104|  3.53k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.53k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.53k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.53k|      {
   44|  3.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.53k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.53k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.53k|      else {
  108|  3.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.53k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.53k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.39k, False: 2.14k]
  ------------------
  143|  1.39k|            if constexpr( has_apply_void ) {
  144|  1.39k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.39k|         }
  156|  3.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.39k, False: 2.14k]
  ------------------
  157|  1.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.39k|         }
  159|  2.14k|         else {
  160|  2.14k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.14k|         }
  162|  3.53k|         (void)m( result );
  163|  3.53k|         return result;
  164|  3.53k|      }
  165|  3.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.53k|      {
   73|  3.53k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.53k|         else {
   84|  3.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.53k|      {
   44|  3.53k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.53k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.53k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.53k|      else {
  108|  3.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 205, False: 3.33k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    205|            else if constexpr( has_apply0_bool ) {
  153|    205|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    205|            }
  155|    205|         }
  156|  3.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 205, False: 3.33k]
  ------------------
  157|    205|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    205|         }
  159|  3.33k|         else {
  160|  3.33k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.33k|         }
  162|  3.53k|         (void)m( result );
  163|  3.53k|         return result;
  164|  3.53k|      }
  165|  3.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.53k|      {
   73|  3.53k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.53k|         else {
   84|  3.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.53k|      {
   59|  3.53k|         return Rule::match( in );
   60|  3.53k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.33k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.33k|      else {
  108|  3.33k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.33k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.33k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.33k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.33k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.33k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.33k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.33k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.33k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.33k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.33k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.33k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.33k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.33k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.33k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.33k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.33k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.33k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.33k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 255, False: 3.07k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    255|            else if constexpr( has_apply0_bool ) {
  153|    255|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    255|            }
  155|    255|         }
  156|  3.33k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 255, False: 3.07k]
  ------------------
  157|    255|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    255|         }
  159|  3.07k|         else {
  160|  3.07k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.07k|         }
  162|  3.33k|         (void)m( result );
  163|  3.33k|         return result;
  164|  3.33k|      }
  165|  3.33k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.33k|      {
   73|  3.33k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.33k|         else {
   84|  3.33k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.33k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.33k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.33k|      {
   59|  3.33k|         return Rule::match( in );
   60|  3.33k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.07k|      else {
  108|  3.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.07k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.07k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.07k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.07k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.07k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.07k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.07k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.07k|         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.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 197, False: 2.88k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    197|            else if constexpr( has_apply0_bool ) {
  153|    197|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    197|            }
  155|    197|         }
  156|  3.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 197, False: 2.88k]
  ------------------
  157|    197|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    197|         }
  159|  2.88k|         else {
  160|  2.88k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.88k|         }
  162|  3.07k|         (void)m( result );
  163|  3.07k|         return result;
  164|  3.07k|      }
  165|  3.07k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.07k|      {
   73|  3.07k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.07k|         else {
   84|  3.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.07k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.07k|      {
   59|  3.07k|         return Rule::match( in );
   60|  3.07k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.88k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.88k|      else {
  108|  2.88k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.88k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.88k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.88k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.88k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.88k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.88k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.88k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.88k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.88k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.88k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.88k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.88k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.88k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.88k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.88k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.88k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.88k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.88k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 277, False: 2.60k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    277|            else if constexpr( has_apply0_bool ) {
  153|    277|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    277|            }
  155|    277|         }
  156|  2.88k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 277, False: 2.60k]
  ------------------
  157|    277|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    277|         }
  159|  2.60k|         else {
  160|  2.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.60k|         }
  162|  2.88k|         (void)m( result );
  163|  2.88k|         return result;
  164|  2.88k|      }
  165|  2.88k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.88k|      {
   73|  2.88k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.88k|         else {
   84|  2.88k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.88k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.88k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.88k|      {
   59|  2.88k|         return Rule::match( in );
   60|  2.88k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.60k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.60k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.60k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.60k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.60k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 257, False: 2.34k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    257|            else if constexpr( has_apply0_bool ) {
  153|    257|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    257|            }
  155|    257|         }
  156|  2.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 257, False: 2.34k]
  ------------------
  157|    257|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    257|         }
  159|  2.34k|         else {
  160|  2.34k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.34k|         }
  162|  2.60k|         (void)m( result );
  163|  2.60k|         return result;
  164|  2.60k|      }
  165|  2.60k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.34k|      else {
  108|  2.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.34k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.34k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.34k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.34k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 202, False: 2.14k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    202|            else if constexpr( has_apply0_bool ) {
  153|    202|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    202|            }
  155|    202|         }
  156|  2.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 202, False: 2.14k]
  ------------------
  157|    202|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    202|         }
  159|  2.14k|         else {
  160|  2.14k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.14k|         }
  162|  2.34k|         (void)m( result );
  163|  2.34k|         return result;
  164|  2.34k|      }
  165|  2.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.34k|      {
   73|  2.34k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.34k|         else {
   84|  2.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.34k|      {
   59|  2.34k|         return Rule::match( in );
   60|  2.34k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.53k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.53k|      else {
  108|  3.53k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.53k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.53k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.53k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.53k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.53k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.53k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.53k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.53k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.53k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.53k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.53k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.53k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.53k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.53k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.53k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.53k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.53k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.53k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.35k, False: 1.18k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.35k|            else if constexpr( has_apply0_bool ) {
  153|  2.35k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.35k|            }
  155|  2.35k|         }
  156|  3.53k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.35k, False: 1.18k]
  ------------------
  157|  2.35k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.35k|         }
  159|  1.18k|         else {
  160|  1.18k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.18k|         }
  162|  3.53k|         (void)m( result );
  163|  3.53k|         return result;
  164|  3.53k|      }
  165|  3.53k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.53k|      {
   73|  3.53k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.53k|         else {
   84|  3.53k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.53k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.53k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.53k|      {
   59|  3.53k|         return Rule::match( in );
   60|  3.53k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.64k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.64k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.64k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.64k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.64k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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.64k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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 ) {
  ------------------
  |  Branch (156:14): [True: 4.64k, False: 0]
  ------------------
  157|  4.64k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.64k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.64k|         (void)m( result );
  163|  4.64k|         return result;
  164|  4.64k|      }
  165|  4.64k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.64k|      {
   73|  4.64k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_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_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.35k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.35k|      else {
  108|  2.35k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.35k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.35k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.35k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.35k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.35k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.35k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.35k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.35k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.35k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.35k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.35k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.35k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.35k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.35k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.35k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.35k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.35k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.35k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.28k, False: 73]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.28k|            else if constexpr( has_apply0_bool ) {
  153|  2.28k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.28k|            }
  155|  2.28k|         }
  156|  2.35k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.28k, False: 73]
  ------------------
  157|  2.28k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.28k|         }
  159|     73|         else {
  160|     73|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     73|         }
  162|  2.35k|         (void)m( result );
  163|  2.35k|         return result;
  164|  2.35k|      }
  165|  2.35k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.35k|      {
   73|  2.35k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.35k|         else {
   84|  2.35k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.35k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.35k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.35k|      {
   44|  2.35k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.35k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.30k|   {
  104|  2.30k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.30k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.30k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_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_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.81k|   {
  104|  5.81k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.81k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  5.81k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.81k|      {
   44|  5.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.81k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.28k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.28k|      else {
  108|  2.28k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.28k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.28k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.28k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.28k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.28k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.28k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.28k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.28k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.28k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.28k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.28k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.28k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.28k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.28k|         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.28k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.28k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.28k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.28k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.28k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.14k, False: 138]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.14k|            else if constexpr( has_apply0_bool ) {
  153|  2.14k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.14k|            }
  155|  2.14k|         }
  156|  2.28k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.14k, False: 138]
  ------------------
  157|  2.14k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.14k|         }
  159|    138|         else {
  160|    138|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    138|         }
  162|  2.28k|         (void)m( result );
  163|  2.28k|         return result;
  164|  2.28k|      }
  165|  2.28k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.28k|      {
   73|  2.28k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.28k|         else {
   84|  2.28k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.28k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.28k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.28k|      {
   59|  2.28k|         return Rule::match( in );
   60|  2.28k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.04k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.04k|      else {
  108|  8.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  8.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 8.04k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 8.04k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.62k, False: 1.42k]
  ------------------
  143|  6.62k|            if constexpr( has_apply_void ) {
  144|  6.62k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  6.62k|         }
  156|  8.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.57k, False: 1.47k]
  ------------------
  157|  6.57k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.57k|         }
  159|  1.47k|         else {
  160|  1.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.47k|         }
  162|  8.04k|         (void)m( result );
  163|  8.04k|         return result;
  164|  8.04k|      }
  165|  8.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  8.04k|      {
   73|  8.04k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.04k|         else {
   84|  8.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.04k|      {
   44|  8.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.04k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.04k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.04k|      else {
  108|  8.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.04k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.04k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.04k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.87k, False: 1.17k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.87k|            else if constexpr( has_apply0_bool ) {
  153|  6.87k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.87k|            }
  155|  6.87k|         }
  156|  8.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.87k, False: 1.17k]
  ------------------
  157|  6.87k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.87k|         }
  159|  1.17k|         else {
  160|  1.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.17k|         }
  162|  8.04k|         (void)m( result );
  163|  8.04k|         return result;
  164|  8.04k|      }
  165|  8.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  8.04k|      {
   73|  8.04k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.04k|         else {
   84|  8.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.04k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  8.04k|      {
   59|  8.04k|         return Rule::match( in );
   60|  8.04k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.87k|   {
  104|  6.87k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.87k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  6.87k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.87k|      {
   44|  6.87k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.87k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  6.87k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.87k|      else {
  108|  6.87k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.87k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.87k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.87k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.87k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.87k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.87k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.87k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.87k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.87k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.87k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.87k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.87k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.87k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.87k|         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.87k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.87k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.87k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.87k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.87k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.62k, False: 253]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.62k|            else if constexpr( has_apply0_bool ) {
  153|  6.62k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.62k|            }
  155|  6.62k|         }
  156|  6.87k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.62k, False: 253]
  ------------------
  157|  6.62k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.62k|         }
  159|    253|         else {
  160|    253|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    253|         }
  162|  6.87k|         (void)m( result );
  163|  6.87k|         return result;
  164|  6.87k|      }
  165|  6.87k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  6.87k|      {
   73|  6.87k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.87k|         else {
   84|  6.87k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.87k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.87k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.87k|      {
   44|  6.87k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.87k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.78M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.78M|      else {
  108|  7.78M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.78M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.78M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  7.78M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.78M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.78M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.78M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.78M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  7.78M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.78M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.78M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.78M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  7.78M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.78M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.78M|         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.78M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.78M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.78M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.78M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.78M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.62k, False: 7.78M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.62k|            else if constexpr( has_apply0_bool ) {
  153|  6.62k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.62k|            }
  155|  6.62k|         }
  156|  7.78M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.62k, False: 7.78M]
  ------------------
  157|  6.62k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.62k|         }
  159|  7.78M|         else {
  160|  7.78M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.78M|         }
  162|  7.78M|         (void)m( result );
  163|  7.78M|         return result;
  164|  7.78M|      }
  165|  7.78M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.78M|      {
   73|  7.78M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  7.78M|         else {
   84|  7.78M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.78M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.78M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.78M|      {
   59|  7.78M|         return Rule::match( in );
   60|  7.78M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.78M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.78M|      else {
  108|  7.78M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.78M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.78M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  7.78M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.78M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.78M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.78M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.78M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  7.78M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.78M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.78M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.78M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  7.78M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.78M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.78M|         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.78M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.78M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.78M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.78M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.78M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.78M, False: 253]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.78M|            else if constexpr( has_apply0_bool ) {
  153|  7.78M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.78M|            }
  155|  7.78M|         }
  156|  7.78M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.78M, False: 253]
  ------------------
  157|  7.78M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.78M|         }
  159|    253|         else {
  160|    253|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    253|         }
  162|  7.78M|         (void)m( result );
  163|  7.78M|         return result;
  164|  7.78M|      }
  165|  7.78M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.78M|      {
   73|  7.78M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  7.78M|         else {
   84|  7.78M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.78M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.78M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.78M|      {
   44|  7.78M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.78M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.78M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.78M|      else {
  108|  7.78M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.78M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.78M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  7.78M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.78M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.78M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.78M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.78M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  7.78M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.78M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.78M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.78M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  7.78M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.78M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.78M|         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.78M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.78M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.78M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.78M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.78M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 156k, False: 7.62M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  7.78M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 156k, False: 7.62M]
  ------------------
  157|   156k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   156k|         }
  159|  7.62M|         else {
  160|  7.62M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.62M|         }
  162|  7.78M|         (void)m( result );
  163|  7.78M|         return result;
  164|  7.78M|      }
  165|  7.78M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.78M|      {
   73|  7.78M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  7.78M|         else {
   84|  7.78M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.78M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.78M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.78M|      {
   44|  7.78M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.78M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.78M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.78M|      else {
  108|  7.78M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.78M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.78M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  7.78M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.78M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.78M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.78M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.78M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  7.78M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.78M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.78M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.78M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  7.78M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.78M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.78M|         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.78M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.78M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.78M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.78M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.78M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 156k, False: 7.62M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  7.78M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 156k, False: 7.62M]
  ------------------
  157|   156k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   156k|         }
  159|  7.62M|         else {
  160|  7.62M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.62M|         }
  162|  7.78M|         (void)m( result );
  163|  7.78M|         return result;
  164|  7.78M|      }
  165|  7.78M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.78M|      {
   73|  7.78M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  7.78M|         else {
   84|  7.78M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.78M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.78M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.78M|      {
   59|  7.78M|         return Rule::match( in );
   60|  7.78M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   156k|   {
  104|   156k|      if constexpr( !Control< Rule >::enable ) {
  105|   156k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   156k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_19parent_hash_actionsETtTpTyENS0_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_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   156k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   156k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   156k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   156k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   156k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 86]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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 ) {
  ------------------
  |  Branch (156:14): [True: 156k, False: 86]
  ------------------
  157|   156k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   156k|         }
  159|     86|         else {
  160|     86|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     86|         }
  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_modeE2ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   156k|      {
   73|   156k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_modeE2ETtTpTyENS5_19parent_hash_actionsETtTpTyENS0_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_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   156k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   156k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   156k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   156k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   156k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 71.9k, False: 84.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  71.9k|            else if constexpr( has_apply0_bool ) {
  153|  71.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  71.9k|            }
  155|  71.9k|         }
  156|   156k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 71.9k, False: 84.7k]
  ------------------
  157|  71.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  71.9k|         }
  159|  84.7k|         else {
  160|  84.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  84.7k|         }
  162|   156k|         (void)m( result );
  163|   156k|         return result;
  164|   156k|      }
  165|   156k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   156k|      {
   73|   156k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_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_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   156k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   156k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   156k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   156k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   156k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 71.9k, False: 84.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  71.9k|            else if constexpr( has_apply0_bool ) {
  153|  71.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  71.9k|            }
  155|  71.9k|         }
  156|   156k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 71.9k, False: 84.7k]
  ------------------
  157|  71.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  71.9k|         }
  159|  84.7k|         else {
  160|  84.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  84.7k|         }
  162|   156k|         (void)m( result );
  163|   156k|         return result;
  164|   156k|      }
  165|   156k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   156k|      {
   73|   156k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_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_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  71.9k|   {
  104|  71.9k|      if constexpr( !Control< Rule >::enable ) {
  105|  71.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  71.9k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  71.9k|      {
   44|  71.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  71.9k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  71.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  71.9k|      else {
  108|  71.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  71.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  71.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  71.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  71.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  71.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  71.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  71.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  71.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  71.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  71.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  71.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  71.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  71.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  71.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|  71.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  71.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  71.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  71.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  71.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 71.9k, False: 31]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  71.9k|            else if constexpr( has_apply0_bool ) {
  153|  71.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  71.9k|            }
  155|  71.9k|         }
  156|  71.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 71.9k, False: 31]
  ------------------
  157|  71.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  71.9k|         }
  159|     31|         else {
  160|     31|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     31|         }
  162|  71.9k|         (void)m( result );
  163|  71.9k|         return result;
  164|  71.9k|      }
  165|  71.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  71.9k|      {
   73|  71.9k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  71.9k|         else {
   84|  71.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  71.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  71.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  71.9k|      {
   44|  71.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  71.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   143k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   143k|      else {
  108|   143k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   143k|         using iterator_t = typename ParseInput::iterator_t;
  111|   143k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   143k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   143k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   143k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   143k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   143k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   143k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   143k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   143k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   143k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   143k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   143k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   143k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   143k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   143k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   143k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   143k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   143k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 143k, False: 31]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   143k|            else if constexpr( has_apply0_bool ) {
  153|   143k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   143k|            }
  155|   143k|         }
  156|   143k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 143k, False: 31]
  ------------------
  157|   143k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   143k|         }
  159|     31|         else {
  160|     31|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     31|         }
  162|   143k|         (void)m( result );
  163|   143k|         return result;
  164|   143k|      }
  165|   143k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   143k|      {
   73|   143k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   143k|         else {
   84|   143k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   143k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   143k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   143k|      {
   59|   143k|         return Rule::match( in );
   60|   143k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  84.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  84.7k|      else {
  108|  84.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  84.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  84.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  84.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  84.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  84.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  84.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  84.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  84.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  84.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  84.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  84.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  84.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  84.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  84.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|  84.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  84.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  84.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  84.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  84.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 25.2k, False: 59.5k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  25.2k|            else if constexpr( has_apply0_bool ) {
  153|  25.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  25.2k|            }
  155|  25.2k|         }
  156|  84.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 25.2k, False: 59.5k]
  ------------------
  157|  25.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  25.2k|         }
  159|  59.5k|         else {
  160|  59.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  59.5k|         }
  162|  84.7k|         (void)m( result );
  163|  84.7k|         return result;
  164|  84.7k|      }
  165|  84.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  84.7k|      {
   73|  84.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  84.7k|         else {
   84|  84.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  84.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  84.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  84.7k|      {
   44|  84.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  84.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   118k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   118k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   118k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   118k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   118k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 40.7k, False: 77.8k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  40.7k|            else if constexpr( has_apply0_bool ) {
  153|  40.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  40.7k|            }
  155|  40.7k|         }
  156|   118k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 40.7k, False: 77.8k]
  ------------------
  157|  40.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  40.7k|         }
  159|  77.8k|         else {
  160|  77.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  77.8k|         }
  162|   118k|         (void)m( result );
  163|   118k|         return result;
  164|   118k|      }
  165|   118k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   118k|      {
   73|   118k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_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|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  25.2k|   {
  104|  25.2k|      if constexpr( !Control< Rule >::enable ) {
  105|  25.2k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  25.2k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  25.2k|      {
   44|  25.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  25.2k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  25.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  25.2k|      else {
  108|  25.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  25.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  25.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  25.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  25.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  25.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  25.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  25.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  25.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  25.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  25.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  25.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  25.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  25.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  25.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|  25.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  25.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  25.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  25.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  25.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 25.2k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  25.2k|            else if constexpr( has_apply0_bool ) {
  153|  25.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  25.2k|            }
  155|  25.2k|         }
  156|  25.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 25.2k, False: 0]
  ------------------
  157|  25.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  25.2k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  25.2k|         (void)m( result );
  163|  25.2k|         return result;
  164|  25.2k|      }
  165|  25.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  25.2k|      {
   73|  25.2k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  25.2k|         else {
   84|  25.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  25.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  25.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  25.2k|      {
   44|  25.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  25.2k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  59.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  59.5k|      else {
  108|  59.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  59.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  59.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  59.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  59.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  59.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  59.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  59.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  59.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  59.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  59.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  59.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  59.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  59.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  59.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|  59.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  59.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  59.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  59.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  59.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 57.3k, False: 2.15k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  57.3k|            else if constexpr( has_apply0_bool ) {
  153|  57.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  57.3k|            }
  155|  57.3k|         }
  156|  59.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 57.3k, False: 2.15k]
  ------------------
  157|  57.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  57.3k|         }
  159|  2.15k|         else {
  160|  2.15k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.15k|         }
  162|  59.5k|         (void)m( result );
  163|  59.5k|         return result;
  164|  59.5k|      }
  165|  59.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  59.5k|      {
   73|  59.5k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  59.5k|         else {
   84|  59.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  59.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  59.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  59.5k|      {
   59|  59.5k|         return Rule::match( in );
   60|  59.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.15k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.15k|      else {
  108|  2.15k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.15k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.15k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.15k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.15k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.15k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.15k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.15k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.15k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.15k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.15k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.15k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.15k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.15k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.15k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.15k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.15k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.15k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.15k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.10k, False: 55]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.10k|            else if constexpr( has_apply0_bool ) {
  153|  2.10k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.10k|            }
  155|  2.10k|         }
  156|  2.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.10k, False: 55]
  ------------------
  157|  2.10k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.10k|         }
  159|     55|         else {
  160|     55|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     55|         }
  162|  2.15k|         (void)m( result );
  163|  2.15k|         return result;
  164|  2.15k|      }
  165|  2.15k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.15k|      {
   73|  2.15k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.15k|         else {
   84|  2.15k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.15k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.15k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.15k|      {
   59|  2.15k|         return Rule::match( in );
   60|  2.15k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.62M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.62M|      else {
  108|  7.62M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.62M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.62M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  7.62M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.62M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.62M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.62M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.62M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  7.62M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.62M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.62M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.62M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  7.62M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.62M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.62M|         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.62M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.62M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.62M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.62M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.62M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.62M, False: 167]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.62M|            else if constexpr( has_apply0_bool ) {
  153|  7.62M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.62M|            }
  155|  7.62M|         }
  156|  7.62M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.62M, False: 167]
  ------------------
  157|  7.62M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.62M|         }
  159|    167|         else {
  160|    167|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    167|         }
  162|  7.62M|         (void)m( result );
  163|  7.62M|         return result;
  164|  7.62M|      }
  165|  7.62M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.62M|      {
   73|  7.62M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  7.62M|         else {
   84|  7.62M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.62M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.62M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.62M|      {
   59|  7.62M|         return Rule::match( in );
   60|  7.62M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser16serial_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  28.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  28.1k|      else {
  108|  28.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  28.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  28.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  28.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  28.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  28.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  28.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  28.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  28.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  28.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  28.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  28.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  28.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  28.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  28.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|  28.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  28.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  28.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  28.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  28.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.42k, False: 25.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.42k|            else if constexpr( has_apply0_bool ) {
  153|  2.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.42k|            }
  155|  2.42k|         }
  156|  28.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.42k, False: 25.7k]
  ------------------
  157|  2.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.42k|         }
  159|  25.7k|         else {
  160|  25.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  25.7k|         }
  162|  28.1k|         (void)m( result );
  163|  28.1k|         return result;
  164|  28.1k|      }
  165|  28.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser16serial_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  28.1k|      {
   73|  28.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  28.1k|         else {
   84|  28.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  28.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  28.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser16serial_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  28.1k|      {
   44|  28.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  28.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  28.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  28.1k|      else {
  108|  28.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  28.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  28.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  28.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  28.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  28.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  28.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  28.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  28.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  28.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  28.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  28.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  28.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  28.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  28.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|  28.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  28.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  28.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  28.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  28.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.42k, False: 25.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.42k|            else if constexpr( has_apply0_bool ) {
  153|  2.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.42k|            }
  155|  2.42k|         }
  156|  28.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.42k, False: 25.7k]
  ------------------
  157|  2.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.42k|         }
  159|  25.7k|         else {
  160|  25.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  25.7k|         }
  162|  28.1k|         (void)m( result );
  163|  28.1k|         return result;
  164|  28.1k|      }
  165|  28.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_10str_serialENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  28.1k|      {
   73|  28.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  28.1k|         else {
   84|  28.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  28.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  28.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_10str_serialENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  28.1k|      {
   44|  28.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  28.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_serialELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  28.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  28.1k|      else {
  108|  28.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  28.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  28.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  28.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  28.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 28.1k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  28.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  28.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  28.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  28.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  28.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  28.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  28.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  28.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  28.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  28.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|  28.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 28.1k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  28.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  28.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  28.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  28.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.90k, False: 25.2k]
  ------------------
  143|  2.90k|            if constexpr( has_apply_void ) {
  144|  2.90k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  2.90k|         }
  156|  28.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.90k, False: 25.2k]
  ------------------
  157|  2.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.90k|         }
  159|  25.2k|         else {
  160|  25.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  25.2k|         }
  162|  28.1k|         (void)m( result );
  163|  28.1k|         return result;
  164|  28.1k|      }
  165|  28.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_serialELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  28.1k|      {
   73|  28.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  28.1k|         else {
   84|  28.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  28.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  28.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_serialELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  28.1k|      {
   59|  28.1k|         return Rule::match( in );
   60|  28.1k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  8.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.12k|      else {
  108|  8.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.12k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.12k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.12k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.12k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.12k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.12k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.12k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.12k|         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.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.59k, False: 1.52k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.59k|            else if constexpr( has_apply0_bool ) {
  153|  6.59k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.59k|            }
  155|  6.59k|         }
  156|  8.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.59k, False: 1.52k]
  ------------------
  157|  6.59k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.59k|         }
  159|  1.52k|         else {
  160|  1.52k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.52k|         }
  162|  8.12k|         (void)m( result );
  163|  8.12k|         return result;
  164|  8.12k|      }
  165|  8.12k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  8.12k|      {
   73|  8.12k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.12k|         else {
   84|  8.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.12k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.12k|      {
   44|  8.12k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.12k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  8.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.12k|      else {
  108|  8.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.12k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.12k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.12k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.12k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.12k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.12k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.12k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.12k|         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.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.59k, False: 1.52k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.59k|            else if constexpr( has_apply0_bool ) {
  153|  6.59k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.59k|            }
  155|  6.59k|         }
  156|  8.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.59k, False: 1.52k]
  ------------------
  157|  6.59k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.59k|         }
  159|  1.52k|         else {
  160|  1.52k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.52k|         }
  162|  8.12k|         (void)m( result );
  163|  8.12k|         return result;
  164|  8.12k|      }
  165|  8.12k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  8.12k|      {
   73|  8.12k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.12k|         else {
   84|  8.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.12k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  8.12k|      {
   59|  8.12k|         return Rule::match( in );
   60|  8.12k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  15.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  15.0k|      else {
  108|  15.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  15.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  15.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  15.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  15.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  15.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  15.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  15.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.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|  15.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  15.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.83k, False: 10.1k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.83k|            else if constexpr( has_apply0_bool ) {
  153|  4.83k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.83k|            }
  155|  4.83k|         }
  156|  15.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.83k, False: 10.1k]
  ------------------
  157|  4.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.83k|         }
  159|  10.1k|         else {
  160|  10.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.1k|         }
  162|  15.0k|         (void)m( result );
  163|  15.0k|         return result;
  164|  15.0k|      }
  165|  15.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  15.0k|      {
   73|  15.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  15.0k|         else {
   84|  15.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  15.0k|      {
   59|  15.0k|         return Rule::match( in );
   60|  15.0k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.89k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.89k|      else {
  108|  2.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.42k, False: 463]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.42k|            else if constexpr( has_apply0_bool ) {
  153|  2.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.42k|            }
  155|  2.42k|         }
  156|  2.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.42k, False: 463]
  ------------------
  157|  2.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.42k|         }
  159|    463|         else {
  160|    463|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    463|         }
  162|  2.89k|         (void)m( result );
  163|  2.89k|         return result;
  164|  2.89k|      }
  165|  2.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.89k|      {
   73|  2.89k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.89k|         else {
   84|  2.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.89k|      {
   44|  2.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.89k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.89k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.89k|      else {
  108|  2.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.67k, False: 1.21k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  2.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.67k, False: 1.21k]
  ------------------
  157|  1.67k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.67k|         }
  159|  1.21k|         else {
  160|  1.21k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.21k|         }
  162|  2.89k|         (void)m( result );
  163|  2.89k|         return result;
  164|  2.89k|      }
  165|  2.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.89k|      {
   73|  2.89k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.89k|         else {
   84|  2.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.89k|      {
   44|  2.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.89k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.89k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.89k|      else {
  108|  2.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.89k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.89k|            else if constexpr( has_apply0_bool ) {
  153|  2.89k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.89k|            }
  155|  2.89k|         }
  156|  2.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.89k, False: 0]
  ------------------
  157|  2.89k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.89k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  2.89k|         (void)m( result );
  163|  2.89k|         return result;
  164|  2.89k|      }
  165|  2.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.89k|      {
   73|  2.89k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.89k|         else {
   84|  2.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.89k|      {
   44|  2.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.89k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  2.89k|   {
  104|  2.89k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.89k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.89k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.89k|      {
   44|  2.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.89k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.89k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.89k|      else {
  108|  2.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  2.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 2.89k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 2.89k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.49k, False: 1.39k]
  ------------------
  143|  1.49k|            if constexpr( has_apply_void ) {
  144|  1.49k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.49k|         }
  156|  2.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.49k, False: 1.39k]
  ------------------
  157|  1.49k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.49k|         }
  159|  1.39k|         else {
  160|  1.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.39k|         }
  162|  2.89k|         (void)m( result );
  163|  2.89k|         return result;
  164|  2.89k|      }
  165|  2.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.89k|      {
   73|  2.89k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.89k|         else {
   84|  2.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.89k|      {
   44|  2.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.89k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.89k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.89k|      else {
  108|  2.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 216, False: 2.67k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    216|            else if constexpr( has_apply0_bool ) {
  153|    216|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    216|            }
  155|    216|         }
  156|  2.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 216, False: 2.67k]
  ------------------
  157|    216|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    216|         }
  159|  2.67k|         else {
  160|  2.67k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.67k|         }
  162|  2.89k|         (void)m( result );
  163|  2.89k|         return result;
  164|  2.89k|      }
  165|  2.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.89k|      {
   73|  2.89k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.89k|         else {
   84|  2.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.89k|      {
   59|  2.89k|         return Rule::match( in );
   60|  2.89k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.67k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.67k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.67k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.67k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.67k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 224, False: 2.45k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    224|            else if constexpr( has_apply0_bool ) {
  153|    224|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    224|            }
  155|    224|         }
  156|  2.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 224, False: 2.45k]
  ------------------
  157|    224|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    224|         }
  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_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 195, False: 2.25k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    195|            else if constexpr( has_apply0_bool ) {
  153|    195|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    195|            }
  155|    195|         }
  156|  2.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 195, False: 2.25k]
  ------------------
  157|    195|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    195|         }
  159|  2.25k|         else {
  160|  2.25k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.25k|         }
  162|  2.45k|         (void)m( result );
  163|  2.45k|         return result;
  164|  2.45k|      }
  165|  2.45k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.25k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.25k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.25k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.25k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.25k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 66, False: 2.19k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|     66|            else if constexpr( has_apply0_bool ) {
  153|     66|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     66|            }
  155|     66|         }
  156|  2.25k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 66, False: 2.19k]
  ------------------
  157|     66|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     66|         }
  159|  2.19k|         else {
  160|  2.19k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.19k|         }
  162|  2.25k|         (void)m( result );
  163|  2.25k|         return result;
  164|  2.25k|      }
  165|  2.25k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.25k|      {
   73|  2.25k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.25k|      {
   59|  2.25k|         return Rule::match( in );
   60|  2.25k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.19k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.19k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.19k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.19k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.19k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.19k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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 ) {
  ------------------
  |  Branch (142:14): [True: 332, False: 1.85k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    332|            else if constexpr( has_apply0_bool ) {
  153|    332|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    332|            }
  155|    332|         }
  156|  2.19k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 332, False: 1.85k]
  ------------------
  157|    332|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    332|         }
  159|  1.85k|         else {
  160|  1.85k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.85k|         }
  162|  2.19k|         (void)m( result );
  163|  2.19k|         return result;
  164|  2.19k|      }
  165|  2.19k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.19k|      {
   73|  2.19k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.19k|         else {
   84|  2.19k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.19k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.19k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.19k|      {
   59|  2.19k|         return Rule::match( in );
   60|  2.19k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.85k|      else {
  108|  1.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.85k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.85k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.85k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.85k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.85k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.85k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.85k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.85k|         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.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 465, False: 1.39k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    465|            else if constexpr( has_apply0_bool ) {
  153|    465|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    465|            }
  155|    465|         }
  156|  1.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 465, False: 1.39k]
  ------------------
  157|    465|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    465|         }
  159|  1.39k|         else {
  160|  1.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.39k|         }
  162|  1.85k|         (void)m( result );
  163|  1.85k|         return result;
  164|  1.85k|      }
  165|  1.85k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.85k|      {
   73|  1.85k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.85k|         else {
   84|  1.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.85k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.85k|      {
   59|  1.85k|         return Rule::match( in );
   60|  1.85k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.89k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.89k|      else {
  108|  2.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.89k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.89k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.89k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.89k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.89k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.89k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.89k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.81k, False: 1.07k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.81k|            else if constexpr( has_apply0_bool ) {
  153|  1.81k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.81k|            }
  155|  1.81k|         }
  156|  2.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.81k, False: 1.07k]
  ------------------
  157|  1.81k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.81k|         }
  159|  1.07k|         else {
  160|  1.07k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.07k|         }
  162|  2.89k|         (void)m( result );
  163|  2.89k|         return result;
  164|  2.89k|      }
  165|  2.89k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.89k|      {
   73|  2.89k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.89k|         else {
   84|  2.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.89k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.89k|      {
   59|  2.89k|         return Rule::match( in );
   60|  2.89k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.58k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.58k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.58k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.58k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.58k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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 ) {
  ------------------
  |  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_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  3.58k|      {
   73|  3.58k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_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_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  1.81k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.81k|      else {
  108|  1.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.76k, False: 48]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.76k|            else if constexpr( has_apply0_bool ) {
  153|  1.76k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.76k|            }
  155|  1.76k|         }
  156|  1.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.76k, False: 48]
  ------------------
  157|  1.76k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.76k|         }
  159|     48|         else {
  160|     48|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     48|         }
  162|  1.81k|         (void)m( result );
  163|  1.81k|         return result;
  164|  1.81k|      }
  165|  1.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  1.81k|      {
   73|  1.81k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.81k|         else {
   84|  1.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  1.81k|      {
   44|  1.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.81k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  1.77k|   {
  104|  1.77k|      if constexpr( !Control< Rule >::enable ) {
  105|  1.77k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  1.77k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  1.77k|      {
   44|  1.77k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.77k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.71k|   {
  104|  3.71k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.71k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.71k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.71k|      {
   44|  3.71k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.71k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.76k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.76k|      else {
  108|  1.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.76k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.76k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.76k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.76k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.76k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.76k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.76k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.67k, False: 95]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.67k, False: 95]
  ------------------
  157|  1.67k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.67k|         }
  159|     95|         else {
  160|     95|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     95|         }
  162|  1.76k|         (void)m( result );
  163|  1.76k|         return result;
  164|  1.76k|      }
  165|  1.76k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.76k|      {
   73|  1.76k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.76k|         else {
   84|  1.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.76k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.76k|      {
   59|  1.76k|         return Rule::match( in );
   60|  1.76k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.25k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.25k|      else {
  108|  5.25k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.25k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.25k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  5.25k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.25k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 5.25k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.25k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.25k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.25k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.25k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.25k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.25k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.25k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.25k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.25k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.25k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 5.25k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.25k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.25k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.25k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.25k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.48k, False: 773]
  ------------------
  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|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  4.48k|         }
  156|  5.25k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.47k, False: 785]
  ------------------
  157|  4.47k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.47k|         }
  159|    785|         else {
  160|    785|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    785|         }
  162|  5.25k|         (void)m( result );
  163|  5.25k|         return result;
  164|  5.25k|      }
  165|  5.25k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.25k|      {
   73|  5.25k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.25k|         else {
   84|  5.25k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.25k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.25k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.25k|      {
   44|  5.25k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.25k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.25k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.25k|      else {
  108|  5.25k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.25k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.25k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.25k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.25k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.25k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.25k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.25k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.25k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.25k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.25k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.25k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.25k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.25k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.25k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.25k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.25k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.25k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.25k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.69k, False: 562]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.69k|            else if constexpr( has_apply0_bool ) {
  153|  4.69k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.69k|            }
  155|  4.69k|         }
  156|  5.25k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.69k, False: 562]
  ------------------
  157|  4.69k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.69k|         }
  159|    562|         else {
  160|    562|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    562|         }
  162|  5.25k|         (void)m( result );
  163|  5.25k|         return result;
  164|  5.25k|      }
  165|  5.25k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  5.25k|      {
   73|  5.25k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.25k|         else {
   84|  5.25k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.25k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.25k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.25k|      {
   59|  5.25k|         return Rule::match( in );
   60|  5.25k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.69k|   {
  104|  4.69k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.69k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.69k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.69k|      {
   44|  4.69k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.69k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  4.69k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.69k|      else {
  108|  4.69k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.69k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.69k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.69k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.69k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.69k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.69k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.69k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.69k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.69k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.69k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.69k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.69k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.69k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.69k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.69k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.69k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.69k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.69k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.48k, False: 211]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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.69k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.48k, False: 211]
  ------------------
  157|  4.48k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.48k|         }
  159|    211|         else {
  160|    211|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    211|         }
  162|  4.69k|         (void)m( result );
  163|  4.69k|         return result;
  164|  4.69k|      }
  165|  4.69k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  4.69k|      {
   73|  4.69k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.69k|         else {
   84|  4.69k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.69k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.69k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.69k|      {
   44|  4.69k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.69k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.50M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.50M|      else {
  108|  2.50M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.50M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.50M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.50M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.50M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.50M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.50M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.50M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.50M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.50M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.50M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.50M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.50M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.50M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.50M|         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.50M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.50M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.50M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.50M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.50M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.48k, False: 2.50M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  2.50M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.48k, False: 2.50M]
  ------------------
  157|  4.48k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.48k|         }
  159|  2.50M|         else {
  160|  2.50M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.50M|         }
  162|  2.50M|         (void)m( result );
  163|  2.50M|         return result;
  164|  2.50M|      }
  165|  2.50M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.50M|      {
   73|  2.50M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.50M|         else {
   84|  2.50M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.50M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.50M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.50M|      {
   59|  2.50M|         return Rule::match( in );
   60|  2.50M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.50M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.50M|      else {
  108|  2.50M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.50M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.50M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.50M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.50M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.50M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.50M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.50M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.50M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.50M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.50M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.50M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.50M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.50M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.50M|         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.50M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.50M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.50M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.50M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.50M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.50M, False: 211]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.50M|            else if constexpr( has_apply0_bool ) {
  153|  2.50M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.50M|            }
  155|  2.50M|         }
  156|  2.50M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.50M, False: 211]
  ------------------
  157|  2.50M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.50M|         }
  159|    211|         else {
  160|    211|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    211|         }
  162|  2.50M|         (void)m( result );
  163|  2.50M|         return result;
  164|  2.50M|      }
  165|  2.50M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.50M|      {
   73|  2.50M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.50M|         else {
   84|  2.50M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.50M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.50M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.50M|      {
   44|  2.50M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.50M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.50M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.50M|      else {
  108|  2.50M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.50M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.50M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.50M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.50M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.50M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.50M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.50M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.50M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.50M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.50M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.50M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.50M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.50M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.50M|         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.50M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.50M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.50M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.50M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.50M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.76k, False: 2.49M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.76k|            else if constexpr( has_apply0_bool ) {
  153|  8.76k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.76k|            }
  155|  8.76k|         }
  156|  2.50M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.76k, False: 2.49M]
  ------------------
  157|  8.76k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.76k|         }
  159|  2.49M|         else {
  160|  2.49M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.49M|         }
  162|  2.50M|         (void)m( result );
  163|  2.50M|         return result;
  164|  2.50M|      }
  165|  2.50M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.50M|      {
   73|  2.50M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.50M|         else {
   84|  2.50M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.50M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.50M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.50M|      {
   44|  2.50M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.50M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.50M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.50M|      else {
  108|  2.50M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.50M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.50M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.50M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.50M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.50M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.50M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.50M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.50M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.50M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.50M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.50M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.50M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.50M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.50M|         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.50M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.50M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.50M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.50M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.50M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.81k, False: 2.49M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.81k|            else if constexpr( has_apply0_bool ) {
  153|  8.81k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.81k|            }
  155|  8.81k|         }
  156|  2.50M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.81k, False: 2.49M]
  ------------------
  157|  8.81k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.81k|         }
  159|  2.49M|         else {
  160|  2.49M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.49M|         }
  162|  2.50M|         (void)m( result );
  163|  2.50M|         return result;
  164|  2.50M|      }
  165|  2.50M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.50M|      {
   73|  2.50M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.50M|         else {
   84|  2.50M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.50M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.50M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.50M|      {
   59|  2.50M|         return Rule::match( in );
   60|  2.50M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  8.81k|   {
  104|  8.81k|      if constexpr( !Control< Rule >::enable ) {
  105|  8.81k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  8.81k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.81k|      {
   44|  8.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.81k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  8.81k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.81k|      else {
  108|  8.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.76k, False: 47]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.76k|            else if constexpr( has_apply0_bool ) {
  153|  8.76k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.76k|            }
  155|  8.76k|         }
  156|  8.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.76k, False: 47]
  ------------------
  157|  8.76k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.76k|         }
  159|     47|         else {
  160|     47|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     47|         }
  162|  8.81k|         (void)m( result );
  163|  8.81k|         return result;
  164|  8.81k|      }
  165|  8.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  8.81k|      {
   73|  8.81k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.81k|         else {
   84|  8.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.81k|      {
   44|  8.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.81k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.81k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.81k|      else {
  108|  8.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.37k, False: 6.43k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  8.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.37k, False: 6.43k]
  ------------------
  157|  2.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.37k|         }
  159|  6.43k|         else {
  160|  6.43k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.43k|         }
  162|  8.81k|         (void)m( result );
  163|  8.81k|         return result;
  164|  8.81k|      }
  165|  8.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  8.81k|      {
   73|  8.81k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.81k|         else {
   84|  8.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.81k|      {
   44|  8.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.81k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  8.81k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.81k|      else {
  108|  8.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.40k, False: 6.41k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.40k|            else if constexpr( has_apply0_bool ) {
  153|  2.40k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.40k|            }
  155|  2.40k|         }
  156|  8.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.40k, False: 6.41k]
  ------------------
  157|  2.40k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.40k|         }
  159|  6.41k|         else {
  160|  6.41k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.41k|         }
  162|  8.81k|         (void)m( result );
  163|  8.81k|         return result;
  164|  8.81k|      }
  165|  8.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  8.81k|      {
   73|  8.81k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.81k|         else {
   84|  8.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  8.81k|      {
   59|  8.81k|         return Rule::match( in );
   60|  8.81k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  2.40k|   {
  104|  2.40k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.40k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.40k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.40k|      {
   44|  2.40k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.40k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.40k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.40k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.40k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.40k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.40k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 2.37k, False: 24]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  2.40k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.37k, False: 24]
  ------------------
  157|  2.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.37k|         }
  159|     24|         else {
  160|     24|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     24|         }
  162|  2.40k|         (void)m( result );
  163|  2.40k|         return result;
  164|  2.40k|      }
  165|  2.40k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  2.40k|      {
   73|  2.40k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.40k|      {
   44|  2.40k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.40k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  4.79k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.79k|      else {
  108|  4.79k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.79k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.79k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.79k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.79k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.79k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.79k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.79k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.79k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.79k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.79k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.79k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.79k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.79k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.79k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.79k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.79k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.79k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.79k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.76k, False: 24]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.76k|            else if constexpr( has_apply0_bool ) {
  153|  4.76k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.76k|            }
  155|  4.76k|         }
  156|  4.79k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.76k, False: 24]
  ------------------
  157|  4.76k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.76k|         }
  159|     24|         else {
  160|     24|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     24|         }
  162|  4.79k|         (void)m( result );
  163|  4.79k|         return result;
  164|  4.79k|      }
  165|  4.79k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  4.79k|      {
   73|  4.79k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.79k|         else {
   84|  4.79k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.79k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.79k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.79k|      {
   59|  4.79k|         return Rule::match( in );
   60|  4.79k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.41k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.41k|      else {
  108|  6.41k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.41k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.41k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.41k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.41k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.41k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.41k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.41k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.41k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.41k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.41k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.41k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.41k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.41k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.41k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.41k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.41k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.41k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.41k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.07k, False: 3.33k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.07k|            else if constexpr( has_apply0_bool ) {
  153|  3.07k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.07k|            }
  155|  3.07k|         }
  156|  6.41k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.07k, False: 3.33k]
  ------------------
  157|  3.07k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.07k|         }
  159|  3.33k|         else {
  160|  3.33k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.33k|         }
  162|  6.41k|         (void)m( result );
  163|  6.41k|         return result;
  164|  6.41k|      }
  165|  6.41k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.41k|      {
   73|  6.41k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.41k|         else {
   84|  6.41k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.41k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.41k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.41k|      {
   44|  6.41k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.41k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  10.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.0k|      else {
  108|  10.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.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|  10.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.16k, False: 5.92k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.16k|            else if constexpr( has_apply0_bool ) {
  153|  4.16k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.16k|            }
  155|  4.16k|         }
  156|  10.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.16k, False: 5.92k]
  ------------------
  157|  4.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.16k|         }
  159|  5.92k|         else {
  160|  5.92k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.92k|         }
  162|  10.0k|         (void)m( result );
  163|  10.0k|         return result;
  164|  10.0k|      }
  165|  10.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  10.0k|      {
   73|  10.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.0k|         else {
   84|  10.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  10.0k|      {
   59|  10.0k|         return Rule::match( in );
   60|  10.0k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  3.07k|   {
  104|  3.07k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.07k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.07k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.07k|      {
   44|  3.07k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.07k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.07k|      else {
  108|  3.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.07k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.07k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.07k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.07k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.07k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.07k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.07k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.07k|         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.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.07k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.07k|            else if constexpr( has_apply0_bool ) {
  153|  3.07k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.07k|            }
  155|  3.07k|         }
  156|  3.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.07k, False: 0]
  ------------------
  157|  3.07k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.07k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.07k|         (void)m( result );
  163|  3.07k|         return result;
  164|  3.07k|      }
  165|  3.07k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  3.07k|      {
   73|  3.07k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.07k|         else {
   84|  3.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.07k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.07k|      {
   44|  3.07k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.07k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.33k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.33k|      else {
  108|  3.33k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.33k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.33k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.33k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.33k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.33k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.33k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.33k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.33k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.33k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.33k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.33k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.33k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.33k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.33k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.33k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.33k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.33k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.33k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.11k, False: 219]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.11k|            else if constexpr( has_apply0_bool ) {
  153|  3.11k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.11k|            }
  155|  3.11k|         }
  156|  3.33k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.11k, False: 219]
  ------------------
  157|  3.11k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.11k|         }
  159|    219|         else {
  160|    219|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    219|         }
  162|  3.33k|         (void)m( result );
  163|  3.33k|         return result;
  164|  3.33k|      }
  165|  3.33k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.33k|      {
   73|  3.33k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.33k|         else {
   84|  3.33k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.33k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.33k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.33k|      {
   59|  3.33k|         return Rule::match( in );
   60|  3.33k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    219|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    219|      else {
  108|    219|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    219|         using iterator_t = typename ParseInput::iterator_t;
  111|    219|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    219|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    219|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    219|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    219|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    219|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    219|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    219|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    219|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    219|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    219|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    219|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    219|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    219|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    219|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    219|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    219|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    219|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 196, False: 23]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    196|            else if constexpr( has_apply0_bool ) {
  153|    196|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    196|            }
  155|    196|         }
  156|    219|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 196, False: 23]
  ------------------
  157|    196|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    196|         }
  159|     23|         else {
  160|     23|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     23|         }
  162|    219|         (void)m( result );
  163|    219|         return result;
  164|    219|      }
  165|    219|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    219|      {
   73|    219|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    219|         else {
   84|    219|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    219|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    219|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|    219|      {
   59|    219|         return Rule::match( in );
   60|    219|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.49M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.49M|      else {
  108|  2.49M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.49M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.49M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.49M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.49M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.49M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.49M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.49M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.49M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.49M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.49M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.49M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.49M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.49M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.49M|         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.49M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.49M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.49M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.49M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.49M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.49M, False: 164]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.49M|            else if constexpr( has_apply0_bool ) {
  153|  2.49M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.49M|            }
  155|  2.49M|         }
  156|  2.49M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.49M, False: 164]
  ------------------
  157|  2.49M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.49M|         }
  159|    164|         else {
  160|    164|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    164|         }
  162|  2.49M|         (void)m( result );
  163|  2.49M|         return result;
  164|  2.49M|      }
  165|  2.49M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.49M|      {
   73|  2.49M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.49M|         else {
   84|  2.49M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.49M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.49M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.49M|      {
   59|  2.49M|         return Rule::match( in );
   60|  2.49M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18via_port_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  25.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  25.4k|      else {
  108|  25.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  25.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  25.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  25.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  25.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  25.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  25.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  25.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  25.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  25.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  25.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  25.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  25.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  25.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  25.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|  25.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  25.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  25.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  25.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  25.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.78k, False: 22.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.78k|            else if constexpr( has_apply0_bool ) {
  153|  2.78k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.78k|            }
  155|  2.78k|         }
  156|  25.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.78k, False: 22.7k]
  ------------------
  157|  2.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.78k|         }
  159|  22.7k|         else {
  160|  22.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  22.7k|         }
  162|  25.4k|         (void)m( result );
  163|  25.4k|         return result;
  164|  25.4k|      }
  165|  25.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18via_port_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  25.4k|      {
   73|  25.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  25.4k|         else {
   84|  25.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  25.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  25.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18via_port_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  25.4k|      {
   44|  25.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  25.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  25.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  25.4k|      else {
  108|  25.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  25.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  25.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  25.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  25.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  25.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  25.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  25.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  25.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  25.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  25.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  25.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  25.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  25.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  25.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|  25.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  25.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  25.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  25.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  25.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.78k, False: 22.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.78k|            else if constexpr( has_apply0_bool ) {
  153|  2.78k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.78k|            }
  155|  2.78k|         }
  156|  25.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.78k, False: 22.7k]
  ------------------
  157|  2.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.78k|         }
  159|  22.7k|         else {
  160|  22.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  22.7k|         }
  162|  25.4k|         (void)m( result );
  163|  25.4k|         return result;
  164|  25.4k|      }
  165|  25.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_12str_via_portENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  25.4k|      {
   73|  25.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  25.4k|         else {
   84|  25.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  25.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  25.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_12str_via_portENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  25.4k|      {
   44|  25.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  25.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12str_via_portELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  25.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  25.4k|      else {
  108|  25.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  25.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  25.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  25.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  25.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 25.4k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  25.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  25.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  25.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  25.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  25.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  25.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  25.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  25.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  25.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  25.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|  25.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 25.4k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  25.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  25.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  25.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  25.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.45k, False: 22.0k]
  ------------------
  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|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  3.45k|         }
  156|  25.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.45k, False: 22.0k]
  ------------------
  157|  3.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.45k|         }
  159|  22.0k|         else {
  160|  22.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  22.0k|         }
  162|  25.4k|         (void)m( result );
  163|  25.4k|         return result;
  164|  25.4k|      }
  165|  25.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12str_via_portELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  25.4k|      {
   73|  25.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  25.4k|         else {
   84|  25.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  25.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  25.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12str_via_portELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  25.4k|      {
   59|  25.4k|         return Rule::match( in );
   60|  25.4k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  9.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.45k|      else {
  108|  9.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.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|  9.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.45k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.94k, False: 1.51k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.94k|            else if constexpr( has_apply0_bool ) {
  153|  7.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.94k|            }
  155|  7.94k|         }
  156|  9.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.94k, False: 1.51k]
  ------------------
  157|  7.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.94k|         }
  159|  1.51k|         else {
  160|  1.51k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.51k|         }
  162|  9.45k|         (void)m( result );
  163|  9.45k|         return result;
  164|  9.45k|      }
  165|  9.45k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  9.45k|      {
   73|  9.45k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.45k|         else {
   84|  9.45k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.45k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.45k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  9.45k|      {
   44|  9.45k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.45k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  9.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.45k|      else {
  108|  9.45k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.45k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.45k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.45k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  9.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  9.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  9.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  9.45k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.45k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.45k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.45k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  9.45k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.45k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.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|  9.45k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.45k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.45k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.45k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.45k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.94k, False: 1.51k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.94k|            else if constexpr( has_apply0_bool ) {
  153|  7.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.94k|            }
  155|  7.94k|         }
  156|  9.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.94k, False: 1.51k]
  ------------------
  157|  7.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.94k|         }
  159|  1.51k|         else {
  160|  1.51k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.51k|         }
  162|  9.45k|         (void)m( result );
  163|  9.45k|         return result;
  164|  9.45k|      }
  165|  9.45k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  9.45k|      {
   73|  9.45k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  9.45k|         else {
   84|  9.45k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.45k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.45k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.45k|      {
   59|  9.45k|         return Rule::match( in );
   60|  9.45k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  17.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  17.6k|      else {
  108|  17.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  17.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  17.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  17.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  17.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  17.6k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  17.6k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  17.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  17.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  17.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  17.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  17.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  17.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  17.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  17.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|  17.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  17.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  17.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  17.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  17.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.42k, False: 12.2k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.42k|            else if constexpr( has_apply0_bool ) {
  153|  5.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.42k|            }
  155|  5.42k|         }
  156|  17.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.42k, False: 12.2k]
  ------------------
  157|  5.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.42k|         }
  159|  12.2k|         else {
  160|  12.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  12.2k|         }
  162|  17.6k|         (void)m( result );
  163|  17.6k|         return result;
  164|  17.6k|      }
  165|  17.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  17.6k|      {
   73|  17.6k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  17.6k|         else {
   84|  17.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  17.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  17.6k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  17.6k|      {
   59|  17.6k|         return Rule::match( in );
   60|  17.6k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.43k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.43k|      else {
  108|  3.43k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.43k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.43k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.43k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.43k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.43k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.43k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.43k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.43k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.43k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.43k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.43k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.43k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.43k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.43k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.43k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.43k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.43k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.43k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.78k, False: 655]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.78k|            else if constexpr( has_apply0_bool ) {
  153|  2.78k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.78k|            }
  155|  2.78k|         }
  156|  3.43k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.78k, False: 655]
  ------------------
  157|  2.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.78k|         }
  159|    655|         else {
  160|    655|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    655|         }
  162|  3.43k|         (void)m( result );
  163|  3.43k|         return result;
  164|  3.43k|      }
  165|  3.43k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.43k|      {
   73|  3.43k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.43k|         else {
   84|  3.43k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.43k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.43k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.43k|      {
   44|  3.43k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.43k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.43k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.43k|      else {
  108|  3.43k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.43k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.43k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.43k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.43k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.43k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.43k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.43k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.43k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.43k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.43k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.43k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.43k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.43k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.43k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.43k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.43k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.43k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.43k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.99k, False: 1.43k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.99k|            else if constexpr( has_apply0_bool ) {
  153|  1.99k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.99k|            }
  155|  1.99k|         }
  156|  3.43k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.99k, False: 1.43k]
  ------------------
  157|  1.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.99k|         }
  159|  1.43k|         else {
  160|  1.43k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.43k|         }
  162|  3.43k|         (void)m( result );
  163|  3.43k|         return result;
  164|  3.43k|      }
  165|  3.43k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.43k|      {
   73|  3.43k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.43k|         else {
   84|  3.43k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.43k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.43k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.43k|      {
   44|  3.43k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.43k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.43k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.43k|      else {
  108|  3.43k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.43k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.43k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.43k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.43k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.43k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.43k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.43k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.43k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.43k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.43k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.43k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.43k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.43k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.43k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.43k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.43k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.43k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.43k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.43k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.43k|            else if constexpr( has_apply0_bool ) {
  153|  3.43k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.43k|            }
  155|  3.43k|         }
  156|  3.43k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.43k, False: 0]
  ------------------
  157|  3.43k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.43k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.43k|         (void)m( result );
  163|  3.43k|         return result;
  164|  3.43k|      }
  165|  3.43k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.43k|      {
   73|  3.43k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.43k|         else {
   84|  3.43k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.43k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.43k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.43k|      {
   44|  3.43k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.43k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.43k|   {
  104|  3.43k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.43k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.43k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.43k|      {
   44|  3.43k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.43k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.43k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.43k|      else {
  108|  3.43k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.43k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.43k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  3.43k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.43k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.43k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.43k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.43k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.43k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.43k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.43k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.43k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.43k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.43k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.43k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.43k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.43k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.43k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.43k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.43k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.43k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.30k, False: 2.13k]
  ------------------
  143|  1.30k|            if constexpr( has_apply_void ) {
  144|  1.30k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.30k|         }
  156|  3.43k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.30k, False: 2.13k]
  ------------------
  157|  1.30k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.30k|         }
  159|  2.13k|         else {
  160|  2.13k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.13k|         }
  162|  3.43k|         (void)m( result );
  163|  3.43k|         return result;
  164|  3.43k|      }
  165|  3.43k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.43k|      {
   73|  3.43k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.43k|         else {
   84|  3.43k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.43k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.43k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.43k|      {
   44|  3.43k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.43k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.43k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.43k|      else {
  108|  3.43k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.43k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.43k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.43k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.43k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.43k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.43k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.43k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.43k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.43k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.43k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.43k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.43k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.43k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.43k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.43k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.43k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.43k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.43k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 210, False: 3.22k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    210|            else if constexpr( has_apply0_bool ) {
  153|    210|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    210|            }
  155|    210|         }
  156|  3.43k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 210, False: 3.22k]
  ------------------
  157|    210|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    210|         }
  159|  3.22k|         else {
  160|  3.22k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.22k|         }
  162|  3.43k|         (void)m( result );
  163|  3.43k|         return result;
  164|  3.43k|      }
  165|  3.43k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.43k|      {
   73|  3.43k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.43k|         else {
   84|  3.43k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.43k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.43k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.43k|      {
   59|  3.43k|         return Rule::match( in );
   60|  3.43k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.22k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.22k|      else {
  108|  3.22k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.22k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.22k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.22k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.22k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.22k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.22k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.22k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.22k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.22k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.22k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.22k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.22k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.22k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.22k|         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.22k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.22k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.22k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.22k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.22k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 218, False: 3.00k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    218|            else if constexpr( has_apply0_bool ) {
  153|    218|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    218|            }
  155|    218|         }
  156|  3.22k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 218, False: 3.00k]
  ------------------
  157|    218|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    218|         }
  159|  3.00k|         else {
  160|  3.00k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.00k|         }
  162|  3.22k|         (void)m( result );
  163|  3.22k|         return result;
  164|  3.22k|      }
  165|  3.22k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.22k|      {
   73|  3.22k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.22k|         else {
   84|  3.22k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.22k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.22k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.22k|      {
   59|  3.22k|         return Rule::match( in );
   60|  3.22k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.00k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.00k|      else {
  108|  3.00k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.00k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.00k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.00k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.00k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.00k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.00k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.00k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.00k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.00k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.00k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.00k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.00k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.00k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.00k|         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.00k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.00k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.00k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.00k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.00k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 2.81k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    194|            else if constexpr( has_apply0_bool ) {
  153|    194|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    194|            }
  155|    194|         }
  156|  3.00k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.81k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.81k|         else {
  160|  2.81k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.81k|         }
  162|  3.00k|         (void)m( result );
  163|  3.00k|         return result;
  164|  3.00k|      }
  165|  3.00k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.00k|      {
   73|  3.00k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.00k|         else {
   84|  3.00k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.00k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.00k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.00k|      {
   59|  3.00k|         return Rule::match( in );
   60|  3.00k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.81k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 195, False: 2.61k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    195|            else if constexpr( has_apply0_bool ) {
  153|    195|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    195|            }
  155|    195|         }
  156|  2.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 195, False: 2.61k]
  ------------------
  157|    195|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    195|         }
  159|  2.61k|         else {
  160|  2.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.61k|         }
  162|  2.81k|         (void)m( result );
  163|  2.81k|         return result;
  164|  2.81k|      }
  165|  2.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_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_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.61k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.61k|      else {
  108|  2.61k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.61k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.61k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.61k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.61k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.61k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.61k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.61k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.61k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.61k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.61k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.61k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.61k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.61k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.61k|         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.61k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.61k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.61k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.61k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.61k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 272, False: 2.34k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    272|            else if constexpr( has_apply0_bool ) {
  153|    272|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    272|            }
  155|    272|         }
  156|  2.61k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 272, False: 2.34k]
  ------------------
  157|    272|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    272|         }
  159|  2.34k|         else {
  160|  2.34k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.34k|         }
  162|  2.61k|         (void)m( result );
  163|  2.61k|         return result;
  164|  2.61k|      }
  165|  2.61k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.61k|      {
   73|  2.61k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.61k|         else {
   84|  2.61k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.61k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.61k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.61k|      {
   59|  2.61k|         return Rule::match( in );
   60|  2.61k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.34k|      else {
  108|  2.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.34k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.34k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.34k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.34k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.34k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.34k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.34k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 212, False: 2.13k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    212|            else if constexpr( has_apply0_bool ) {
  153|    212|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    212|            }
  155|    212|         }
  156|  2.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 212, False: 2.13k]
  ------------------
  157|    212|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    212|         }
  159|  2.13k|         else {
  160|  2.13k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.13k|         }
  162|  2.34k|         (void)m( result );
  163|  2.34k|         return result;
  164|  2.34k|      }
  165|  2.34k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.34k|      {
   73|  2.34k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.34k|         else {
   84|  2.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.34k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.34k|      {
   59|  2.34k|         return Rule::match( in );
   60|  2.34k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.43k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.43k|      else {
  108|  3.43k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.43k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.43k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.43k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.43k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.43k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.43k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.43k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.43k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.43k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.43k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.43k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.43k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.43k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.43k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.43k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.43k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.43k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.43k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.19k, False: 1.24k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  3.43k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.19k, False: 1.24k]
  ------------------
  157|  2.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.19k|         }
  159|  1.24k|         else {
  160|  1.24k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.24k|         }
  162|  3.43k|         (void)m( result );
  163|  3.43k|         return result;
  164|  3.43k|      }
  165|  3.43k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.43k|      {
   73|  3.43k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.43k|         else {
   84|  3.43k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.43k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.43k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.43k|      {
   59|  3.43k|         return Rule::match( in );
   60|  3.43k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.32k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.32k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.32k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.32k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.32k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.32k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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 ) {
  ------------------
  |  Branch (142:14): [True: 4.32k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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 ) {
  ------------------
  |  Branch (156:14): [True: 4.32k, False: 0]
  ------------------
  157|  4.32k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.32k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.32k|         (void)m( result );
  163|  4.32k|         return result;
  164|  4.32k|      }
  165|  4.32k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.32k|      {
   73|  4.32k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.32k|         else {
   84|  4.32k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.32k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.32k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_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_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.19k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.19k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.19k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.19k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.19k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.19k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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 ) {
  ------------------
  |  Branch (142:14): [True: 2.12k, False: 70]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.12k|            else if constexpr( has_apply0_bool ) {
  153|  2.12k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.12k|            }
  155|  2.12k|         }
  156|  2.19k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.12k, False: 70]
  ------------------
  157|  2.12k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.12k|         }
  159|     70|         else {
  160|     70|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     70|         }
  162|  2.19k|         (void)m( result );
  163|  2.19k|         return result;
  164|  2.19k|      }
  165|  2.19k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.19k|      {
   73|  2.19k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.19k|         else {
   84|  2.19k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.19k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.19k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_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_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.13k|   {
  104|  2.13k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.13k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.13k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.13k|      {
   44|  2.13k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.13k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.70k|   {
  104|  4.70k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.70k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.70k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.70k|      {
   44|  4.70k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.70k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.12k|      else {
  108|  2.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.12k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.12k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.12k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.12k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.12k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.12k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.12k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.12k|         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.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.99k, False: 127]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.99k|            else if constexpr( has_apply0_bool ) {
  153|  1.99k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.99k|            }
  155|  1.99k|         }
  156|  2.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.99k, False: 127]
  ------------------
  157|  1.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.99k|         }
  159|    127|         else {
  160|    127|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    127|         }
  162|  2.12k|         (void)m( result );
  163|  2.12k|         return result;
  164|  2.12k|      }
  165|  2.12k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.12k|      {
   73|  2.12k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.12k|         else {
   84|  2.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.12k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.12k|      {
   59|  2.12k|         return Rule::match( in );
   60|  2.12k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.86k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.86k|      else {
  108|  6.86k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.86k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.86k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  6.86k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.86k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 6.86k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.86k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.86k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.86k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.86k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.86k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.86k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.86k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.86k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.86k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.86k|         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.86k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 6.86k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.86k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.86k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.86k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.86k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.52k, False: 1.33k]
  ------------------
  143|  5.52k|            if constexpr( has_apply_void ) {
  144|  5.52k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  5.52k|         }
  156|  6.86k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.48k, False: 1.37k]
  ------------------
  157|  5.48k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.48k|         }
  159|  1.37k|         else {
  160|  1.37k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.37k|         }
  162|  6.86k|         (void)m( result );
  163|  6.86k|         return result;
  164|  6.86k|      }
  165|  6.86k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.86k|      {
   73|  6.86k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.86k|         else {
   84|  6.86k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.86k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.86k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.86k|      {
   44|  6.86k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.86k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.86k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.86k|      else {
  108|  6.86k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.86k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.86k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.86k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.86k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.86k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.86k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.86k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.86k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.86k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.86k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.86k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.86k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.86k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.86k|         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.86k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.86k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.86k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.86k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.86k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.81k, False: 1.04k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.81k|            else if constexpr( has_apply0_bool ) {
  153|  5.81k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.81k|            }
  155|  5.81k|         }
  156|  6.86k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.81k, False: 1.04k]
  ------------------
  157|  5.81k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.81k|         }
  159|  1.04k|         else {
  160|  1.04k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.04k|         }
  162|  6.86k|         (void)m( result );
  163|  6.86k|         return result;
  164|  6.86k|      }
  165|  6.86k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.86k|      {
   73|  6.86k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.86k|         else {
   84|  6.86k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.86k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.86k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.86k|      {
   59|  6.86k|         return Rule::match( in );
   60|  6.86k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.81k|   {
  104|  5.81k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.81k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  5.81k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.81k|      {
   44|  5.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.81k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  5.81k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.81k|      else {
  108|  5.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.52k, False: 285]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.52k|            else if constexpr( has_apply0_bool ) {
  153|  5.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.52k|            }
  155|  5.52k|         }
  156|  5.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.52k, False: 285]
  ------------------
  157|  5.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.52k|         }
  159|    285|         else {
  160|    285|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    285|         }
  162|  5.81k|         (void)m( result );
  163|  5.81k|         return result;
  164|  5.81k|      }
  165|  5.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  5.81k|      {
   73|  5.81k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.81k|         else {
   84|  5.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.81k|      {
   44|  5.81k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.81k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.19M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.19M|      else {
  108|  6.19M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.19M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.19M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.19M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.19M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.19M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.19M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.19M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.19M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.19M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.19M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.19M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.19M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.19M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.19M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.19M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.19M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.19M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.19M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.52k, False: 6.18M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.52k|            else if constexpr( has_apply0_bool ) {
  153|  5.52k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.52k|            }
  155|  5.52k|         }
  156|  6.19M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.52k, False: 6.18M]
  ------------------
  157|  5.52k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.52k|         }
  159|  6.18M|         else {
  160|  6.18M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.18M|         }
  162|  6.19M|         (void)m( result );
  163|  6.19M|         return result;
  164|  6.19M|      }
  165|  6.19M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.19M|      {
   73|  6.19M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.19M|         else {
   84|  6.19M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.19M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.19M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.19M|      {
   59|  6.19M|         return Rule::match( in );
   60|  6.19M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.18M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.18M|      else {
  108|  6.18M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.18M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.18M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.18M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.18M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.18M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.18M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.18M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.18M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.18M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.18M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.18M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.18M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.18M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.18M|         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.18M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.18M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.18M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.18M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.18M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.18M, False: 285]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.18M|            else if constexpr( has_apply0_bool ) {
  153|  6.18M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.18M|            }
  155|  6.18M|         }
  156|  6.18M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.18M, False: 285]
  ------------------
  157|  6.18M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.18M|         }
  159|    285|         else {
  160|    285|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    285|         }
  162|  6.18M|         (void)m( result );
  163|  6.18M|         return result;
  164|  6.18M|      }
  165|  6.18M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.18M|      {
   73|  6.18M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.18M|         else {
   84|  6.18M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.18M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.18M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.18M|      {
   44|  6.18M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.18M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.18M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.18M|      else {
  108|  6.18M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.18M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.18M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.18M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.18M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.18M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.18M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.18M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.18M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.18M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.18M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.18M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.18M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.18M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.18M|         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.18M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.18M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.18M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.18M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.18M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 61.7k, False: 6.12M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  61.7k|            else if constexpr( has_apply0_bool ) {
  153|  61.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  61.7k|            }
  155|  61.7k|         }
  156|  6.18M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 61.7k, False: 6.12M]
  ------------------
  157|  61.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  61.7k|         }
  159|  6.12M|         else {
  160|  6.12M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.12M|         }
  162|  6.18M|         (void)m( result );
  163|  6.18M|         return result;
  164|  6.18M|      }
  165|  6.18M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.18M|      {
   73|  6.18M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.18M|         else {
   84|  6.18M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.18M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.18M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.18M|      {
   44|  6.18M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.18M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.18M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.18M|      else {
  108|  6.18M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.18M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.18M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.18M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.18M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.18M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.18M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.18M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.18M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.18M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.18M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.18M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.18M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.18M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.18M|         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.18M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.18M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.18M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.18M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.18M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 61.8k, False: 6.12M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  61.8k|            else if constexpr( has_apply0_bool ) {
  153|  61.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  61.8k|            }
  155|  61.8k|         }
  156|  6.18M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 61.8k, False: 6.12M]
  ------------------
  157|  61.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  61.8k|         }
  159|  6.12M|         else {
  160|  6.12M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.12M|         }
  162|  6.18M|         (void)m( result );
  163|  6.18M|         return result;
  164|  6.18M|      }
  165|  6.18M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.18M|      {
   73|  6.18M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.18M|         else {
   84|  6.18M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.18M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.18M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.18M|      {
   59|  6.18M|         return Rule::match( in );
   60|  6.18M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  61.8k|   {
  104|  61.8k|      if constexpr( !Control< Rule >::enable ) {
  105|  61.8k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  61.8k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  61.8k|      {
   44|  61.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  61.8k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  61.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  61.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  61.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  61.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  61.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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.7k, False: 85]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  61.7k|            else if constexpr( has_apply0_bool ) {
  153|  61.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  61.7k|            }
  155|  61.7k|         }
  156|  61.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 61.7k, False: 85]
  ------------------
  157|  61.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  61.7k|         }
  159|     85|         else {
  160|     85|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     85|         }
  162|  61.8k|         (void)m( result );
  163|  61.8k|         return result;
  164|  61.8k|      }
  165|  61.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  61.8k|      {
   73|  61.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  61.8k|      {
   44|  61.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  61.8k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  61.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  61.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  61.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  61.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  61.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 27.0k, False: 34.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  27.0k|            else if constexpr( has_apply0_bool ) {
  153|  27.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  27.0k|            }
  155|  27.0k|         }
  156|  61.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 27.0k, False: 34.7k]
  ------------------
  157|  27.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  27.0k|         }
  159|  34.7k|         else {
  160|  34.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  34.7k|         }
  162|  61.8k|         (void)m( result );
  163|  61.8k|         return result;
  164|  61.8k|      }
  165|  61.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  61.8k|      {
   73|  61.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  61.8k|      {
   44|  61.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  61.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  61.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  61.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  61.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  61.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  61.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 27.0k, False: 34.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  27.0k|            else if constexpr( has_apply0_bool ) {
  153|  27.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  27.0k|            }
  155|  27.0k|         }
  156|  61.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 27.0k, False: 34.7k]
  ------------------
  157|  27.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  27.0k|         }
  159|  34.7k|         else {
  160|  34.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  34.7k|         }
  162|  61.8k|         (void)m( result );
  163|  61.8k|         return result;
  164|  61.8k|      }
  165|  61.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  61.8k|      {
   73|  61.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  61.8k|      {
   59|  61.8k|         return Rule::match( in );
   60|  61.8k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  27.0k|   {
  104|  27.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  27.0k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  27.0k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  27.0k|      {
   44|  27.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.0k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  27.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  27.0k|      else {
  108|  27.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  27.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  27.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  27.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  27.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  27.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  27.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  27.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  27.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  27.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  27.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  27.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  27.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  27.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  27.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|  27.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  27.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  27.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  27.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  27.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 27.0k, False: 25]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  27.0k|            else if constexpr( has_apply0_bool ) {
  153|  27.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  27.0k|            }
  155|  27.0k|         }
  156|  27.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 27.0k, False: 25]
  ------------------
  157|  27.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  27.0k|         }
  159|     25|         else {
  160|     25|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     25|         }
  162|  27.0k|         (void)m( result );
  163|  27.0k|         return result;
  164|  27.0k|      }
  165|  27.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  27.0k|      {
   73|  27.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  27.0k|         else {
   84|  27.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  27.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  27.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  27.0k|      {
   44|  27.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  54.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  54.1k|      else {
  108|  54.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  54.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  54.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  54.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  54.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  54.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  54.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  54.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  54.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  54.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  54.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  54.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  54.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  54.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  54.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|  54.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  54.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  54.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  54.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  54.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 54.1k, False: 25]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  54.1k|            else if constexpr( has_apply0_bool ) {
  153|  54.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  54.1k|            }
  155|  54.1k|         }
  156|  54.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 54.1k, False: 25]
  ------------------
  157|  54.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  54.1k|         }
  159|     25|         else {
  160|     25|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     25|         }
  162|  54.1k|         (void)m( result );
  163|  54.1k|         return result;
  164|  54.1k|      }
  165|  54.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  54.1k|      {
   73|  54.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  54.1k|         else {
   84|  54.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  54.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  54.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  54.1k|      {
   59|  54.1k|         return Rule::match( in );
   60|  54.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  34.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  34.7k|      else {
  108|  34.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  34.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  34.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  34.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  34.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  34.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  34.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  34.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  34.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  34.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  34.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  34.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  34.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  34.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  34.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|  34.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  34.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  34.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  34.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  34.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.9k, False: 20.8k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  13.9k|            else if constexpr( has_apply0_bool ) {
  153|  13.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.9k|            }
  155|  13.9k|         }
  156|  34.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.9k, False: 20.8k]
  ------------------
  157|  13.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.9k|         }
  159|  20.8k|         else {
  160|  20.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  20.8k|         }
  162|  34.7k|         (void)m( result );
  163|  34.7k|         return result;
  164|  34.7k|      }
  165|  34.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  34.7k|      {
   73|  34.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  34.7k|         else {
   84|  34.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  34.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  34.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  34.7k|      {
   44|  34.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  34.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  53.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  53.1k|      else {
  108|  53.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  53.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  53.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  53.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  53.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  53.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  53.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  53.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  53.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  53.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  53.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  53.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  53.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  53.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  53.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|  53.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  53.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  53.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  53.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  53.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 21.5k, False: 31.5k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  21.5k|            else if constexpr( has_apply0_bool ) {
  153|  21.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  21.5k|            }
  155|  21.5k|         }
  156|  53.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 21.5k, False: 31.5k]
  ------------------
  157|  21.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  21.5k|         }
  159|  31.5k|         else {
  160|  31.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  31.5k|         }
  162|  53.1k|         (void)m( result );
  163|  53.1k|         return result;
  164|  53.1k|      }
  165|  53.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  53.1k|      {
   73|  53.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  53.1k|         else {
   84|  53.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  53.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  53.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  53.1k|      {
   59|  53.1k|         return Rule::match( in );
   60|  53.1k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  13.9k|   {
  104|  13.9k|      if constexpr( !Control< Rule >::enable ) {
  105|  13.9k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  13.9k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  13.9k|      {
   44|  13.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  13.9k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  13.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.9k|      else {
  108|  13.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  13.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  13.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  13.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  13.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  13.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  13.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  13.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.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|  13.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.9k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  13.9k|            else if constexpr( has_apply0_bool ) {
  153|  13.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.9k|            }
  155|  13.9k|         }
  156|  13.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.9k, False: 0]
  ------------------
  157|  13.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.9k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  13.9k|         (void)m( result );
  163|  13.9k|         return result;
  164|  13.9k|      }
  165|  13.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  13.9k|      {
   73|  13.9k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  13.9k|         else {
   84|  13.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  13.9k|      {
   44|  13.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  13.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  20.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  20.8k|      else {
  108|  20.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  20.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  20.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  20.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  20.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  20.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  20.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  20.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  20.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  20.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  20.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  20.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  20.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  20.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  20.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|  20.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  20.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  20.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  20.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  20.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 20.4k, False: 407]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  20.4k|            else if constexpr( has_apply0_bool ) {
  153|  20.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  20.4k|            }
  155|  20.4k|         }
  156|  20.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 20.4k, False: 407]
  ------------------
  157|  20.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  20.4k|         }
  159|    407|         else {
  160|    407|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    407|         }
  162|  20.8k|         (void)m( result );
  163|  20.8k|         return result;
  164|  20.8k|      }
  165|  20.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  20.8k|      {
   73|  20.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  20.8k|         else {
   84|  20.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  20.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  20.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  20.8k|      {
   59|  20.8k|         return Rule::match( in );
   60|  20.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    407|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    407|      else {
  108|    407|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    407|         using iterator_t = typename ParseInput::iterator_t;
  111|    407|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    407|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    407|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    407|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    407|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    407|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    407|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    407|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    407|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    407|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    407|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    407|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    407|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    407|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    407|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    407|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    407|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    407|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 347, False: 60]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    347|            else if constexpr( has_apply0_bool ) {
  153|    347|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    347|            }
  155|    347|         }
  156|    407|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 347, False: 60]
  ------------------
  157|    347|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    347|         }
  159|     60|         else {
  160|     60|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     60|         }
  162|    407|         (void)m( result );
  163|    407|         return result;
  164|    407|      }
  165|    407|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    407|      {
   73|    407|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    407|         else {
   84|    407|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    407|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    407|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|    407|      {
   59|    407|         return Rule::match( in );
   60|    407|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.12M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.12M|      else {
  108|  6.12M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.12M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.12M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.12M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.12M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.12M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.12M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.12M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.12M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.12M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.12M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.12M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.12M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.12M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.12M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.12M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.12M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.12M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.12M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.12M, False: 200]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.12M|            else if constexpr( has_apply0_bool ) {
  153|  6.12M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.12M|            }
  155|  6.12M|         }
  156|  6.12M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.12M, False: 200]
  ------------------
  157|  6.12M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.12M|         }
  159|    200|         else {
  160|    200|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    200|         }
  162|  6.12M|         (void)m( result );
  163|  6.12M|         return result;
  164|  6.12M|      }
  165|  6.12M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  6.12M|      {
   73|  6.12M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.12M|         else {
   84|  6.12M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.12M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.12M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  6.12M|      {
   59|  6.12M|         return Rule::match( in );
   60|  6.12M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24with_interface_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  22.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.3k|      else {
  108|  22.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  22.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  22.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  22.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  22.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  22.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  22.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  22.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.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|  22.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.92k, False: 19.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.92k|            else if constexpr( has_apply0_bool ) {
  153|  2.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.92k|            }
  155|  2.92k|         }
  156|  22.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.92k, False: 19.4k]
  ------------------
  157|  2.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.92k|         }
  159|  19.4k|         else {
  160|  19.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  19.4k|         }
  162|  22.3k|         (void)m( result );
  163|  22.3k|         return result;
  164|  22.3k|      }
  165|  22.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24with_interface_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  22.3k|      {
   73|  22.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  22.3k|         else {
   84|  22.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24with_interface_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  22.3k|      {
   44|  22.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  22.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  22.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.3k|      else {
  108|  22.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  22.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  22.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  22.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  22.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  22.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  22.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  22.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.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|  22.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.92k, False: 19.4k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.92k|            else if constexpr( has_apply0_bool ) {
  153|  2.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.92k|            }
  155|  2.92k|         }
  156|  22.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.92k, False: 19.4k]
  ------------------
  157|  2.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.92k|         }
  159|  19.4k|         else {
  160|  19.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  19.4k|         }
  162|  22.3k|         (void)m( result );
  163|  22.3k|         return result;
  164|  22.3k|      }
  165|  22.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_18str_with_interfaceENS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  22.3k|      {
   73|  22.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  22.3k|         else {
   84|  22.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_18str_with_interfaceENS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  22.3k|      {
   44|  22.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  22.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_with_interfaceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  22.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.3k|      else {
  108|  22.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  22.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  22.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 22.3k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  22.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  22.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  22.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  22.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  22.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.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|  22.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 22.3k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.38k, False: 18.9k]
  ------------------
  143|  3.38k|            if constexpr( has_apply_void ) {
  144|  3.38k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  3.38k|         }
  156|  22.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.38k, False: 18.9k]
  ------------------
  157|  3.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.38k|         }
  159|  18.9k|         else {
  160|  18.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  18.9k|         }
  162|  22.3k|         (void)m( result );
  163|  22.3k|         return result;
  164|  22.3k|      }
  165|  22.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_with_interfaceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  22.3k|      {
   73|  22.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  22.3k|         else {
   84|  22.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_with_interfaceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  22.3k|      {
   59|  22.3k|         return Rule::match( in );
   60|  22.3k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   170k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   170k|      else {
  108|   170k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   170k|         using iterator_t = typename ParseInput::iterator_t;
  111|   170k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   170k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   170k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   170k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   170k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   170k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   170k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   170k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   170k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   170k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   170k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   170k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   170k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   170k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   170k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   170k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   170k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   170k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 168k, False: 1.90k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   168k|            else if constexpr( has_apply0_bool ) {
  153|   168k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   168k|            }
  155|   168k|         }
  156|   170k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 168k, False: 1.90k]
  ------------------
  157|   168k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   168k|         }
  159|  1.90k|         else {
  160|  1.90k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.90k|         }
  162|   170k|         (void)m( result );
  163|   170k|         return result;
  164|   170k|      }
  165|   170k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|   170k|      {
   73|   170k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   170k|         else {
   84|   170k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   170k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   170k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   170k|      {
   44|   170k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   170k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   170k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   170k|      else {
  108|   170k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   170k|         using iterator_t = typename ParseInput::iterator_t;
  111|   170k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   170k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   170k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   170k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   170k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   170k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   170k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   170k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   170k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   170k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   170k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   170k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   170k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   170k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   170k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   170k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   170k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   170k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 168k, False: 1.90k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   168k|            else if constexpr( has_apply0_bool ) {
  153|   168k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   168k|            }
  155|   168k|         }
  156|   170k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 168k, False: 1.90k]
  ------------------
  157|   168k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   168k|         }
  159|  1.90k|         else {
  160|  1.90k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.90k|         }
  162|   170k|         (void)m( result );
  163|   170k|         return result;
  164|   170k|      }
  165|   170k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   170k|      {
   73|   170k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   170k|         else {
   84|   170k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   170k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   170k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   170k|      {
   59|   170k|         return Rule::match( in );
   60|   170k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  1.61M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.61M|      else {
  108|  1.61M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.61M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.61M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.61M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.61M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.61M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.61M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.61M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.61M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.61M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.61M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.61M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.61M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.61M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.61M|         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.61M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.61M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.61M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.61M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.61M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.43M, False: 173k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.43M|            else if constexpr( has_apply0_bool ) {
  153|  1.43M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.43M|            }
  155|  1.43M|         }
  156|  1.61M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.43M, False: 173k]
  ------------------
  157|  1.43M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.43M|         }
  159|   173k|         else {
  160|   173k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   173k|         }
  162|  1.61M|         (void)m( result );
  163|  1.61M|         return result;
  164|  1.61M|      }
  165|  1.61M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  1.61M|      {
   73|  1.61M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.61M|         else {
   84|  1.61M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.61M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.61M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.61M|      {
   59|  1.61M|         return Rule::match( in );
   60|  1.61M|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.38k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.38k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.38k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.38k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.38k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 2.92k, False: 460]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.92k|            else if constexpr( has_apply0_bool ) {
  153|  2.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.92k|            }
  155|  2.92k|         }
  156|  3.38k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.92k, False: 460]
  ------------------
  157|  2.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.92k|         }
  159|    460|         else {
  160|    460|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    460|         }
  162|  3.38k|         (void)m( result );
  163|  3.38k|         return result;
  164|  3.38k|      }
  165|  3.38k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_15interface_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.38k|      {
   73|  3.38k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_15interface_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.38k|      {
   44|  3.38k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.38k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.38k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.38k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.38k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.38k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.38k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 2.21k, False: 1.16k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  3.38k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.21k, False: 1.16k]
  ------------------
  157|  2.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.21k|         }
  159|  1.16k|         else {
  160|  1.16k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.16k|         }
  162|  3.38k|         (void)m( result );
  163|  3.38k|         return result;
  164|  3.38k|      }
  165|  3.38k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.38k|      {
   73|  3.38k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.38k|      {
   44|  3.38k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.38k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.38k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.38k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.38k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.38k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.38k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 3.38k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.38k|            else if constexpr( has_apply0_bool ) {
  153|  3.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.38k|            }
  155|  3.38k|         }
  156|  3.38k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.38k, False: 0]
  ------------------
  157|  3.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.38k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.38k|         (void)m( result );
  163|  3.38k|         return result;
  164|  3.38k|      }
  165|  3.38k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.38k|      {
   73|  3.38k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.38k|      {
   44|  3.38k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.38k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  3.38k|   {
  104|  3.38k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.38k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.38k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.38k|      {
   44|  3.38k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.38k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.38k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.38k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.38k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.38k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.38k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.38k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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): [True: 3.38k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 1.90k, False: 1.47k]
  ------------------
  143|  1.90k|            if constexpr( has_apply_void ) {
  144|  1.90k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.90k|         }
  156|  3.38k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.90k, False: 1.47k]
  ------------------
  157|  1.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.90k|         }
  159|  1.47k|         else {
  160|  1.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.47k|         }
  162|  3.38k|         (void)m( result );
  163|  3.38k|         return result;
  164|  3.38k|      }
  165|  3.38k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.38k|      {
   44|  3.38k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.38k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.38k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.38k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.38k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.38k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.38k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 231, False: 3.14k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    231|            else if constexpr( has_apply0_bool ) {
  153|    231|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    231|            }
  155|    231|         }
  156|  3.38k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 231, False: 3.14k]
  ------------------
  157|    231|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    231|         }
  159|  3.14k|         else {
  160|  3.14k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.14k|         }
  162|  3.38k|         (void)m( result );
  163|  3.38k|         return result;
  164|  3.38k|      }
  165|  3.38k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.14k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.14k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.14k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.14k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.14k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 209, False: 2.94k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    209|            else if constexpr( has_apply0_bool ) {
  153|    209|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    209|            }
  155|    209|         }
  156|  3.14k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 209, False: 2.94k]
  ------------------
  157|    209|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    209|         }
  159|  2.94k|         else {
  160|  2.94k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.94k|         }
  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_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_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_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.94k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.94k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.94k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.94k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.94k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 332, False: 2.60k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    332|            else if constexpr( has_apply0_bool ) {
  153|    332|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    332|            }
  155|    332|         }
  156|  2.94k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 332, False: 2.60k]
  ------------------
  157|    332|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    332|         }
  159|  2.60k|         else {
  160|  2.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.60k|         }
  162|  2.94k|         (void)m( result );
  163|  2.94k|         return result;
  164|  2.94k|      }
  165|  2.94k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.60k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.60k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.60k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.60k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.60k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 333, False: 2.27k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    333|            else if constexpr( has_apply0_bool ) {
  153|    333|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    333|            }
  155|    333|         }
  156|  2.60k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 333, False: 2.27k]
  ------------------
  157|    333|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    333|         }
  159|  2.27k|         else {
  160|  2.27k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.27k|         }
  162|  2.60k|         (void)m( result );
  163|  2.60k|         return result;
  164|  2.60k|      }
  165|  2.60k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.27k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.27k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.27k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.27k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.27k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 496, False: 1.77k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    496|            else if constexpr( has_apply0_bool ) {
  153|    496|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    496|            }
  155|    496|         }
  156|  2.27k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 496, False: 1.77k]
  ------------------
  157|    496|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    496|         }
  159|  1.77k|         else {
  160|  1.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.77k|         }
  162|  2.27k|         (void)m( result );
  163|  2.27k|         return result;
  164|  2.27k|      }
  165|  2.27k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.27k|      {
   73|  2.27k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.27k|      {
   59|  2.27k|         return Rule::match( in );
   60|  2.27k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.77k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.77k|      else {
  108|  1.77k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.77k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.77k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.77k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.77k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.77k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.77k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.77k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.77k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.77k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.77k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.77k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.77k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.77k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.77k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.77k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.77k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.77k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.77k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 307, False: 1.47k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    307|            else if constexpr( has_apply0_bool ) {
  153|    307|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    307|            }
  155|    307|         }
  156|  1.77k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 307, False: 1.47k]
  ------------------
  157|    307|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    307|         }
  159|  1.47k|         else {
  160|  1.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.47k|         }
  162|  1.77k|         (void)m( result );
  163|  1.77k|         return result;
  164|  1.77k|      }
  165|  1.77k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.77k|      {
   73|  1.77k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.77k|         else {
   84|  1.77k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.77k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.77k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.77k|      {
   59|  1.77k|         return Rule::match( in );
   60|  1.77k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.38k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.38k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.38k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.38k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.38k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 2.45k, False: 925]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.45k|            else if constexpr( has_apply0_bool ) {
  153|  2.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.45k|            }
  155|  2.45k|         }
  156|  3.38k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.45k, False: 925]
  ------------------
  157|  2.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.45k|         }
  159|    925|         else {
  160|    925|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    925|         }
  162|  3.38k|         (void)m( result );
  163|  3.38k|         return result;
  164|  3.38k|      }
  165|  3.38k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.38k|      {
   73|  3.38k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.38k|      {
   59|  3.38k|         return Rule::match( in );
   60|  3.38k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.85k|      else {
  108|  4.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.85k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.85k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.85k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.85k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.85k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.85k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.85k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.85k|         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.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.85k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  4.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.85k, False: 0]
  ------------------
  157|  4.85k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.85k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.85k|         (void)m( result );
  163|  4.85k|         return result;
  164|  4.85k|      }
  165|  4.85k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.85k|      {
   73|  4.85k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.85k|         else {
   84|  4.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.85k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.85k|      {
   44|  4.85k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.85k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.45k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.45k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.45k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.45k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.45k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 2.40k, False: 51]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.40k|            else if constexpr( has_apply0_bool ) {
  153|  2.40k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.40k|            }
  155|  2.40k|         }
  156|  2.45k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.40k, False: 51]
  ------------------
  157|  2.40k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.40k|         }
  159|     51|         else {
  160|     51|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     51|         }
  162|  2.45k|         (void)m( result );
  163|  2.45k|         return result;
  164|  2.45k|      }
  165|  2.45k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.45k|      {
   73|  2.45k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.45k|      {
   44|  2.45k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.45k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15interface_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.40k|   {
  104|  2.40k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.40k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.40k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15interface_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.40k|      {
   44|  2.40k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.40k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15interface_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   165k|   {
  104|   165k|      if constexpr( !Control< Rule >::enable ) {
  105|   165k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   165k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15interface_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_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_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.40k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.40k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.40k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.40k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.40k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 2.21k, False: 188]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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.40k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.21k, False: 188]
  ------------------
  157|  2.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.21k|         }
  159|    188|         else {
  160|    188|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    188|         }
  162|  2.40k|         (void)m( result );
  163|  2.40k|         return result;
  164|  2.40k|      }
  165|  2.40k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.40k|      {
   73|  2.40k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.40k|      {
   59|  2.40k|         return Rule::match( in );
   60|  2.40k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15interface_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   166k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   166k|      else {
  108|   166k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   166k|         using iterator_t = typename ParseInput::iterator_t;
  111|   166k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|   166k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   166k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 166k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   166k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   166k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   166k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   166k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   166k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   166k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   166k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   166k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   166k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   166k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   166k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 166k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   166k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   166k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   166k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   166k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 165k, False: 1.05k]
  ------------------
  143|   165k|            if constexpr( has_apply_void ) {
  144|   165k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|   165k|         }
  156|   166k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 165k, False: 1.06k]
  ------------------
  157|   165k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   165k|         }
  159|  1.06k|         else {
  160|  1.06k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.06k|         }
  162|   166k|         (void)m( result );
  163|   166k|         return result;
  164|   166k|      }
  165|   166k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15interface_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   166k|      {
   73|   166k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   166k|         else {
   84|   166k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   166k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   166k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15interface_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   166k|      {
   44|   166k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   166k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   166k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   166k|      else {
  108|   166k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   166k|         using iterator_t = typename ParseInput::iterator_t;
  111|   166k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   166k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   166k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   166k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   166k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   166k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   166k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   166k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   166k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   166k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   166k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   166k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   166k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   166k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   166k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   166k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   166k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   166k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 165k, False: 937]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|   166k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 165k, False: 937]
  ------------------
  157|   165k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   165k|         }
  159|    937|         else {
  160|    937|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    937|         }
  162|   166k|         (void)m( result );
  163|   166k|         return result;
  164|   166k|      }
  165|   166k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   166k|      {
   73|   166k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   166k|         else {
   84|   166k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   166k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   166k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   166k|      {
   44|   166k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   166k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   836k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   836k|      else {
  108|   836k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   836k|         using iterator_t = typename ParseInput::iterator_t;
  111|   836k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   836k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   836k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   836k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   836k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   836k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   836k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   836k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   836k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   836k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   836k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   836k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   836k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   836k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   836k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   836k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   836k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   836k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 675k, False: 160k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   675k|            else if constexpr( has_apply0_bool ) {
  153|   675k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   675k|            }
  155|   675k|         }
  156|   836k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 675k, False: 160k]
  ------------------
  157|   675k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   675k|         }
  159|   160k|         else {
  160|   160k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   160k|         }
  162|   836k|         (void)m( result );
  163|   836k|         return result;
  164|   836k|      }
  165|   836k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   836k|      {
   73|   836k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   836k|         else {
   84|   836k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   836k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   836k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   836k|      {
   59|   836k|         return Rule::match( in );
   60|   836k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   331k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   331k|      else {
  108|   331k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   331k|         using iterator_t = typename ParseInput::iterator_t;
  111|   331k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   331k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   331k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   331k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   331k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   331k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   331k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   331k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   331k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   331k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   331k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   331k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   331k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   331k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   331k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   331k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   331k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   331k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 331k, False: 65]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   331k|            else if constexpr( has_apply0_bool ) {
  153|   331k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   331k|            }
  155|   331k|         }
  156|   331k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 331k, False: 65]
  ------------------
  157|   331k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   331k|         }
  159|     65|         else {
  160|     65|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     65|         }
  162|   331k|         (void)m( result );
  163|   331k|         return result;
  164|   331k|      }
  165|   331k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   331k|      {
   73|   331k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   331k|         else {
   84|   331k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   331k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   331k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   331k|      {
   59|   331k|         return Rule::match( in );
   60|   331k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14hex2orAsteriskELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   331k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   331k|      else {
  108|   331k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   331k|         using iterator_t = typename ParseInput::iterator_t;
  111|   331k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   331k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   331k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   331k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   331k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   331k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   331k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   331k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   331k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   331k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   331k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   331k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   331k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   331k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   331k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   331k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   331k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   331k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 331k, False: 54]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   331k|            else if constexpr( has_apply0_bool ) {
  153|   331k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   331k|            }
  155|   331k|         }
  156|   331k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 331k, False: 54]
  ------------------
  157|   331k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   331k|         }
  159|     54|         else {
  160|     54|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     54|         }
  162|   331k|         (void)m( result );
  163|   331k|         return result;
  164|   331k|      }
  165|   331k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14hex2orAsteriskELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   331k|      {
   73|   331k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   331k|         else {
   84|   331k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   331k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   331k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14hex2orAsteriskELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   331k|      {
   44|   331k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   331k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   331k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   331k|      else {
  108|   331k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   331k|         using iterator_t = typename ParseInput::iterator_t;
  111|   331k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   331k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   331k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   331k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   331k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   331k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   331k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   331k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   331k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   331k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   331k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   331k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   331k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   331k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   331k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   331k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   331k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   331k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 171k, False: 159k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   171k|            else if constexpr( has_apply0_bool ) {
  153|   171k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   171k|            }
  155|   171k|         }
  156|   331k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 171k, False: 159k]
  ------------------
  157|   171k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   171k|         }
  159|   159k|         else {
  160|   159k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   159k|         }
  162|   331k|         (void)m( result );
  163|   331k|         return result;
  164|   331k|      }
  165|   331k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   331k|      {
   73|   331k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   331k|         else {
   84|   331k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   331k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   331k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   331k|      {
   44|   331k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   331k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   159k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   159k|      else {
  108|   159k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   159k|         using iterator_t = typename ParseInput::iterator_t;
  111|   159k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   159k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   159k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   159k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   159k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   159k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   159k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   159k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   159k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   159k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   159k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   159k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   159k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   159k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   159k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   159k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   159k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   159k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 159k, False: 54]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   159k|            else if constexpr( has_apply0_bool ) {
  153|   159k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   159k|            }
  155|   159k|         }
  156|   159k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 159k, False: 54]
  ------------------
  157|   159k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   159k|         }
  159|     54|         else {
  160|     54|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     54|         }
  162|   159k|         (void)m( result );
  163|   159k|         return result;
  164|   159k|      }
  165|   159k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   159k|      {
   73|   159k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   159k|         else {
   84|   159k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   159k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   159k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   159k|      {
   59|   159k|         return Rule::match( in );
   60|   159k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser27with_connect_type_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  19.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  19.4k|      else {
  108|  19.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  19.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  19.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  19.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  19.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  19.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  19.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  19.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  19.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  19.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  19.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  19.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  19.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  19.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  19.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|  19.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  19.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  19.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  19.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  19.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.23k, False: 17.2k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.23k|            else if constexpr( has_apply0_bool ) {
  153|  2.23k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.23k|            }
  155|  2.23k|         }
  156|  19.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.23k, False: 17.2k]
  ------------------
  157|  2.23k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.23k|         }
  159|  17.2k|         else {
  160|  17.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  17.2k|         }
  162|  19.4k|         (void)m( result );
  163|  19.4k|         return result;
  164|  19.4k|      }
  165|  19.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser27with_connect_type_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  19.4k|      {
   73|  19.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  19.4k|         else {
   84|  19.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  19.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  19.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser27with_connect_type_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  19.4k|      {
   44|  19.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  19.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  19.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  19.4k|      else {
  108|  19.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  19.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  19.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  19.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  19.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  19.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  19.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  19.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  19.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  19.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  19.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  19.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  19.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  19.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  19.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|  19.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  19.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  19.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  19.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  19.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.23k, False: 17.2k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.23k|            else if constexpr( has_apply0_bool ) {
  153|  2.23k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.23k|            }
  155|  2.23k|         }
  156|  19.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.23k, False: 17.2k]
  ------------------
  157|  2.23k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.23k|         }
  159|  17.2k|         else {
  160|  17.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  17.2k|         }
  162|  19.4k|         (void)m( result );
  163|  19.4k|         return result;
  164|  19.4k|      }
  165|  19.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_21str_with_connect_typeENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  19.4k|      {
   73|  19.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  19.4k|         else {
   84|  19.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  19.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  19.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_21str_with_connect_typeENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  19.4k|      {
   44|  19.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  19.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser21str_with_connect_typeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  19.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  19.4k|      else {
  108|  19.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  19.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  19.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  19.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  19.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 19.4k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  19.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  19.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  19.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  19.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  19.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  19.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  19.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  19.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  19.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  19.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|  19.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 19.4k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  19.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  19.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  19.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  19.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.84k, False: 16.6k]
  ------------------
  143|  2.84k|            if constexpr( has_apply_void ) {
  144|  2.84k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  2.84k|         }
  156|  19.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.83k, False: 16.6k]
  ------------------
  157|  2.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.83k|         }
  159|  16.6k|         else {
  160|  16.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.6k|         }
  162|  19.4k|         (void)m( result );
  163|  19.4k|         return result;
  164|  19.4k|      }
  165|  19.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser21str_with_connect_typeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  19.4k|      {
   73|  19.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  19.4k|         else {
   84|  19.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  19.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  19.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser21str_with_connect_typeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  19.4k|      {
   59|  19.4k|         return Rule::match( in );
   60|  19.4k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  8.74k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.74k|      else {
  108|  8.74k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.74k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.74k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.74k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.74k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.74k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.74k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.74k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.74k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.74k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.74k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.74k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.74k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.74k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.74k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.74k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.74k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.74k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.74k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.06k, False: 1.68k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.06k|            else if constexpr( has_apply0_bool ) {
  153|  7.06k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.06k|            }
  155|  7.06k|         }
  156|  8.74k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.06k, False: 1.68k]
  ------------------
  157|  7.06k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.06k|         }
  159|  1.68k|         else {
  160|  1.68k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.68k|         }
  162|  8.74k|         (void)m( result );
  163|  8.74k|         return result;
  164|  8.74k|      }
  165|  8.74k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  8.74k|      {
   73|  8.74k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.74k|         else {
   84|  8.74k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.74k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.74k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  8.74k|      {
   44|  8.74k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.74k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  8.74k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.74k|      else {
  108|  8.74k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.74k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.74k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.74k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  8.74k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  8.74k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  8.74k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  8.74k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  8.74k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.74k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.74k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.74k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  8.74k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.74k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.74k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.74k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.74k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.74k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.74k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.06k, False: 1.68k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.06k|            else if constexpr( has_apply0_bool ) {
  153|  7.06k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.06k|            }
  155|  7.06k|         }
  156|  8.74k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.06k, False: 1.68k]
  ------------------
  157|  7.06k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.06k|         }
  159|  1.68k|         else {
  160|  1.68k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.68k|         }
  162|  8.74k|         (void)m( result );
  163|  8.74k|         return result;
  164|  8.74k|      }
  165|  8.74k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  8.74k|      {
   73|  8.74k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  8.74k|         else {
   84|  8.74k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.74k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.74k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  8.74k|      {
   59|  8.74k|         return Rule::match( in );
   60|  8.74k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  17.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  17.3k|      else {
  108|  17.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  17.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  17.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  17.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  17.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  17.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  17.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  17.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  17.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  17.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  17.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  17.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  17.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  17.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  17.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|  17.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  17.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  17.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  17.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  17.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.11k, False: 11.2k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.11k|            else if constexpr( has_apply0_bool ) {
  153|  6.11k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.11k|            }
  155|  6.11k|         }
  156|  17.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.11k, False: 11.2k]
  ------------------
  157|  6.11k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.11k|         }
  159|  11.2k|         else {
  160|  11.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.2k|         }
  162|  17.3k|         (void)m( result );
  163|  17.3k|         return result;
  164|  17.3k|      }
  165|  17.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  17.3k|      {
   73|  17.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  17.3k|         else {
   84|  17.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  17.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  17.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  17.3k|      {
   59|  17.3k|         return Rule::match( in );
   60|  17.3k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.82k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.82k|      else {
  108|  2.82k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.82k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.82k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.82k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.82k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.82k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.82k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.82k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.82k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.82k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.82k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.82k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.82k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.82k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.82k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.82k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.82k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.82k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.82k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.23k, False: 591]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.23k|            else if constexpr( has_apply0_bool ) {
  153|  2.23k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.23k|            }
  155|  2.23k|         }
  156|  2.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.23k, False: 591]
  ------------------
  157|  2.23k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.23k|         }
  159|    591|         else {
  160|    591|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    591|         }
  162|  2.82k|         (void)m( result );
  163|  2.82k|         return result;
  164|  2.82k|      }
  165|  2.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.82k|      {
   73|  2.82k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.82k|         else {
   84|  2.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.82k|      {
   44|  2.82k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.82k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.82k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.82k|      else {
  108|  2.82k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.82k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.82k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.82k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.82k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.82k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.82k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.82k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.82k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.82k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.82k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.82k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.82k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.82k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.82k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.82k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.82k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.82k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.82k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.92k, False: 907]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.92k|            else if constexpr( has_apply0_bool ) {
  153|  1.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.92k|            }
  155|  1.92k|         }
  156|  2.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.92k, False: 907]
  ------------------
  157|  1.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.92k|         }
  159|    907|         else {
  160|    907|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    907|         }
  162|  2.82k|         (void)m( result );
  163|  2.82k|         return result;
  164|  2.82k|      }
  165|  2.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.82k|      {
   73|  2.82k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.82k|         else {
   84|  2.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.82k|      {
   44|  2.82k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.82k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.82k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.82k|      else {
  108|  2.82k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.82k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.82k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.82k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.82k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.82k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.82k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.82k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.82k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.82k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.82k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.82k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.82k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.82k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.82k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.82k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.82k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.82k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.82k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.82k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.82k|            else if constexpr( has_apply0_bool ) {
  153|  2.82k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.82k|            }
  155|  2.82k|         }
  156|  2.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.82k, False: 0]
  ------------------
  157|  2.82k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.82k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  2.82k|         (void)m( result );
  163|  2.82k|         return result;
  164|  2.82k|      }
  165|  2.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.82k|      {
   73|  2.82k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.82k|         else {
   84|  2.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.82k|      {
   44|  2.82k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.82k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  2.82k|   {
  104|  2.82k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.82k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.82k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.82k|      {
   44|  2.82k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.82k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.82k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.82k|      else {
  108|  2.82k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.82k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.82k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  2.82k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.82k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 2.82k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.82k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.82k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.82k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.82k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.82k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.82k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.82k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.82k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.82k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.82k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 2.82k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.82k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.82k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.82k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.82k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.35k, False: 1.47k]
  ------------------
  143|  1.35k|            if constexpr( has_apply_void ) {
  144|  1.35k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.35k|         }
  156|  2.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.35k, False: 1.47k]
  ------------------
  157|  1.35k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.35k|         }
  159|  1.47k|         else {
  160|  1.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.47k|         }
  162|  2.82k|         (void)m( result );
  163|  2.82k|         return result;
  164|  2.82k|      }
  165|  2.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.82k|      {
   73|  2.82k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.82k|         else {
   84|  2.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.82k|      {
   44|  2.82k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.82k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.82k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.82k|      else {
  108|  2.82k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.82k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.82k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.82k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.82k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.82k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.82k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.82k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.82k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.82k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.82k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.82k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.82k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.82k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.82k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.82k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.82k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.82k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.82k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 205, False: 2.62k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    205|            else if constexpr( has_apply0_bool ) {
  153|    205|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    205|            }
  155|    205|         }
  156|  2.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 205, False: 2.62k]
  ------------------
  157|    205|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    205|         }
  159|  2.62k|         else {
  160|  2.62k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.62k|         }
  162|  2.82k|         (void)m( result );
  163|  2.82k|         return result;
  164|  2.82k|      }
  165|  2.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.82k|      {
   73|  2.82k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.82k|         else {
   84|  2.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.82k|      {
   59|  2.82k|         return Rule::match( in );
   60|  2.82k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.62k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.62k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.62k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.62k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.62k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 224, False: 2.40k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    224|            else if constexpr( has_apply0_bool ) {
  153|    224|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    224|            }
  155|    224|         }
  156|  2.62k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 224, False: 2.40k]
  ------------------
  157|    224|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    224|         }
  159|  2.40k|         else {
  160|  2.40k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.40k|         }
  162|  2.62k|         (void)m( result );
  163|  2.62k|         return result;
  164|  2.62k|      }
  165|  2.62k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.62k|      {
   73|  2.62k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.62k|      {
   59|  2.62k|         return Rule::match( in );
   60|  2.62k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.40k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.40k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.40k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.40k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.40k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 226, False: 2.17k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    226|            else if constexpr( has_apply0_bool ) {
  153|    226|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    226|            }
  155|    226|         }
  156|  2.40k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 226, False: 2.17k]
  ------------------
  157|    226|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    226|         }
  159|  2.17k|         else {
  160|  2.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.17k|         }
  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_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_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_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.17k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.17k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.17k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.17k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.17k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 227, False: 1.94k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    227|            else if constexpr( has_apply0_bool ) {
  153|    227|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    227|            }
  155|    227|         }
  156|  2.17k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 227, False: 1.94k]
  ------------------
  157|    227|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    227|         }
  159|  1.94k|         else {
  160|  1.94k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.94k|         }
  162|  2.17k|         (void)m( result );
  163|  2.17k|         return result;
  164|  2.17k|      }
  165|  2.17k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.94k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.94k|      else {
  108|  1.94k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.94k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.94k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.94k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.94k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.94k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.94k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.94k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.94k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.94k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.94k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.94k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.94k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.94k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.94k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.94k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.94k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.94k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.94k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 274, False: 1.67k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    274|            else if constexpr( has_apply0_bool ) {
  153|    274|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    274|            }
  155|    274|         }
  156|  1.94k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 274, False: 1.67k]
  ------------------
  157|    274|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    274|         }
  159|  1.67k|         else {
  160|  1.67k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.67k|         }
  162|  1.94k|         (void)m( result );
  163|  1.94k|         return result;
  164|  1.94k|      }
  165|  1.94k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.94k|      {
   73|  1.94k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.94k|         else {
   84|  1.94k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.94k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.94k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.94k|      {
   59|  1.94k|         return Rule::match( in );
   60|  1.94k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.67k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.67k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.67k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.67k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.67k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.67k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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 ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 1.47k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    194|            else if constexpr( has_apply0_bool ) {
  153|    194|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    194|            }
  155|    194|         }
  156|  1.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 1.47k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  1.47k|         else {
  160|  1.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.47k|         }
  162|  1.67k|         (void)m( result );
  163|  1.67k|         return result;
  164|  1.67k|      }
  165|  1.67k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  1.67k|      {
   73|  1.67k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.67k|         else {
   84|  1.67k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.67k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.67k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.67k|      {
   59|  1.67k|         return Rule::match( in );
   60|  1.67k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.82k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.82k|      else {
  108|  2.82k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.82k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.82k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.82k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.82k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.82k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.82k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.82k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.82k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.82k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.82k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.82k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.82k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.82k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.82k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.82k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.82k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.82k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.82k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.12k, False: 707]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.12k|            else if constexpr( has_apply0_bool ) {
  153|  2.12k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.12k|            }
  155|  2.12k|         }
  156|  2.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.12k, False: 707]
  ------------------
  157|  2.12k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.12k|         }
  159|    707|         else {
  160|    707|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    707|         }
  162|  2.82k|         (void)m( result );
  163|  2.82k|         return result;
  164|  2.82k|      }
  165|  2.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.82k|      {
   73|  2.82k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.82k|         else {
   84|  2.82k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.82k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.82k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.82k|      {
   59|  2.82k|         return Rule::match( in );
   60|  2.82k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.16k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.16k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.16k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.16k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 4.16k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.16k|            else if constexpr( has_apply0_bool ) {
  153|  4.16k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.16k|            }
  155|  4.16k|         }
  156|  4.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.16k, False: 0]
  ------------------
  157|  4.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.16k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.16k|         (void)m( result );
  163|  4.16k|         return result;
  164|  4.16k|      }
  165|  4.16k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.16k|      {
   73|  4.16k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.16k|      {
   44|  4.16k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.16k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.12k|      else {
  108|  2.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.12k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.12k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.12k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.12k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.12k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.12k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.12k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.12k|         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.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.04k, False: 75]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.04k|            else if constexpr( has_apply0_bool ) {
  153|  2.04k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.04k|            }
  155|  2.04k|         }
  156|  2.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.04k, False: 75]
  ------------------
  157|  2.04k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.04k|         }
  159|     75|         else {
  160|     75|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     75|         }
  162|  2.12k|         (void)m( result );
  163|  2.12k|         return result;
  164|  2.12k|      }
  165|  2.12k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.12k|      {
   73|  2.12k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.12k|         else {
   84|  2.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.12k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.12k|      {
   44|  2.12k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.12k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.05k|   {
  104|  2.05k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.05k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.05k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.05k|      {
   44|  2.05k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.05k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.55k|   {
  104|  4.55k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.55k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.55k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.55k|      {
   44|  4.55k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.55k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.04k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.04k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.04k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.04k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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.92k, False: 125]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  1.92k|            else if constexpr( has_apply0_bool ) {
  153|  1.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.92k|            }
  155|  1.92k|         }
  156|  2.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.92k, False: 125]
  ------------------
  157|  1.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.92k|         }
  159|    125|         else {
  160|    125|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    125|         }
  162|  2.04k|         (void)m( result );
  163|  2.04k|         return result;
  164|  2.04k|      }
  165|  2.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.04k|      {
   73|  2.04k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.04k|      {
   59|  2.04k|         return Rule::match( in );
   60|  2.04k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.91k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.91k|      else {
  108|  5.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.91k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  5.91k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.91k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 5.91k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.91k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.91k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.91k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.91k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 5.91k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.92k, False: 989]
  ------------------
  143|  4.92k|            if constexpr( has_apply_void ) {
  144|  4.92k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  4.92k|         }
  156|  5.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.87k, False: 1.03k]
  ------------------
  157|  4.87k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.87k|         }
  159|  1.03k|         else {
  160|  1.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.03k|         }
  162|  5.91k|         (void)m( result );
  163|  5.91k|         return result;
  164|  5.91k|      }
  165|  5.91k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.91k|      {
   73|  5.91k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.91k|         else {
   84|  5.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.91k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.91k|      {
   44|  5.91k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.91k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.91k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.91k|      else {
  108|  5.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.91k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.91k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.91k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.91k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.91k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.91k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.91k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.16k, False: 744]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.16k|            else if constexpr( has_apply0_bool ) {
  153|  5.16k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.16k|            }
  155|  5.16k|         }
  156|  5.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.16k, False: 744]
  ------------------
  157|  5.16k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.16k|         }
  159|    744|         else {
  160|    744|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    744|         }
  162|  5.91k|         (void)m( result );
  163|  5.91k|         return result;
  164|  5.91k|      }
  165|  5.91k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  5.91k|      {
   73|  5.91k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.91k|         else {
   84|  5.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.91k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.91k|      {
   59|  5.91k|         return Rule::match( in );
   60|  5.91k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  5.16k|   {
  104|  5.16k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.16k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  5.16k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.16k|      {
   44|  5.16k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.16k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  5.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.16k|      else {
  108|  5.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.16k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.16k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.16k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.16k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.16k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.16k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.16k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.92k, False: 245]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.92k|            else if constexpr( has_apply0_bool ) {
  153|  4.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.92k|            }
  155|  4.92k|         }
  156|  5.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.92k, False: 245]
  ------------------
  157|  4.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.92k|         }
  159|    245|         else {
  160|    245|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    245|         }
  162|  5.16k|         (void)m( result );
  163|  5.16k|         return result;
  164|  5.16k|      }
  165|  5.16k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  5.16k|      {
   73|  5.16k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.16k|         else {
   84|  5.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.16k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.16k|      {
   44|  5.16k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.16k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.34M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.34M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.34M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.34M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.34M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 4.92k, False: 7.34M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.92k|            else if constexpr( has_apply0_bool ) {
  153|  4.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.92k|            }
  155|  4.92k|         }
  156|  7.34M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.92k, False: 7.34M]
  ------------------
  157|  4.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.92k|         }
  159|  7.34M|         else {
  160|  7.34M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.34M|         }
  162|  7.34M|         (void)m( result );
  163|  7.34M|         return result;
  164|  7.34M|      }
  165|  7.34M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.34M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.34M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.34M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.34M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.34M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 245]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.34M|            else if constexpr( has_apply0_bool ) {
  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: 245]
  ------------------
  157|  7.34M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.34M|         }
  159|    245|         else {
  160|    245|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    245|         }
  162|  7.34M|         (void)m( result );
  163|  7.34M|         return result;
  164|  7.34M|      }
  165|  7.34M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_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_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.34M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.34M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.34M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.34M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.34M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 91.9k, False: 7.24M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  91.9k|            else if constexpr( has_apply0_bool ) {
  153|  91.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  91.9k|            }
  155|  91.9k|         }
  156|  7.34M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 91.9k, False: 7.24M]
  ------------------
  157|  91.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  91.9k|         }
  159|  7.24M|         else {
  160|  7.24M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.24M|         }
  162|  7.34M|         (void)m( result );
  163|  7.34M|         return result;
  164|  7.34M|      }
  165|  7.34M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_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_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.34M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.34M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.34M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.34M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.34M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 92.0k, False: 7.24M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  92.0k|            else if constexpr( has_apply0_bool ) {
  153|  92.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  92.0k|            }
  155|  92.0k|         }
  156|  7.34M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 92.0k, False: 7.24M]
  ------------------
  157|  92.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  92.0k|         }
  159|  7.24M|         else {
  160|  7.24M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.24M|         }
  162|  7.34M|         (void)m( result );
  163|  7.34M|         return result;
  164|  7.34M|      }
  165|  7.34M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_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_modeE1ETtTpTyENS6_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  92.0k|   {
  104|  92.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  92.0k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  92.0k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  92.0k|      {
   44|  92.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  92.0k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  92.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  92.0k|      else {
  108|  92.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  92.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  92.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  92.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  92.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  92.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  92.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  92.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  92.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  92.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  92.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  92.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  92.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  92.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  92.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|  92.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  92.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  92.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  92.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  92.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 91.9k, False: 69]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  91.9k|            else if constexpr( has_apply0_bool ) {
  153|  91.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  91.9k|            }
  155|  91.9k|         }
  156|  92.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 91.9k, False: 69]
  ------------------
  157|  91.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  91.9k|         }
  159|     69|         else {
  160|     69|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     69|         }
  162|  92.0k|         (void)m( result );
  163|  92.0k|         return result;
  164|  92.0k|      }
  165|  92.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  92.0k|      {
   73|  92.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  92.0k|         else {
   84|  92.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  92.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  92.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  92.0k|      {
   44|  92.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  92.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  92.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  92.0k|      else {
  108|  92.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  92.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  92.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  92.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  92.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  92.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  92.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  92.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  92.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  92.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  92.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  92.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  92.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  92.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  92.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|  92.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  92.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  92.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  92.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  92.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 21.2k, False: 70.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  21.2k|            else if constexpr( has_apply0_bool ) {
  153|  21.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  21.2k|            }
  155|  21.2k|         }
  156|  92.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 21.2k, False: 70.7k]
  ------------------
  157|  21.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  21.2k|         }
  159|  70.7k|         else {
  160|  70.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  70.7k|         }
  162|  92.0k|         (void)m( result );
  163|  92.0k|         return result;
  164|  92.0k|      }
  165|  92.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  92.0k|      {
   73|  92.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  92.0k|         else {
   84|  92.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  92.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  92.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  92.0k|      {
   44|  92.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  92.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  92.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  92.0k|      else {
  108|  92.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  92.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  92.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  92.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  92.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  92.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  92.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  92.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  92.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  92.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  92.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  92.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  92.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  92.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  92.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|  92.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  92.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  92.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  92.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  92.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 21.2k, False: 70.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  21.2k|            else if constexpr( has_apply0_bool ) {
  153|  21.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  21.2k|            }
  155|  21.2k|         }
  156|  92.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 21.2k, False: 70.7k]
  ------------------
  157|  21.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  21.2k|         }
  159|  70.7k|         else {
  160|  70.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  70.7k|         }
  162|  92.0k|         (void)m( result );
  163|  92.0k|         return result;
  164|  92.0k|      }
  165|  92.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  92.0k|      {
   73|  92.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  92.0k|         else {
   84|  92.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  92.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  92.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  92.0k|      {
   59|  92.0k|         return Rule::match( in );
   60|  92.0k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  21.2k|   {
  104|  21.2k|      if constexpr( !Control< Rule >::enable ) {
  105|  21.2k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  21.2k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  21.2k|      {
   44|  21.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  21.2k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  21.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  21.2k|      else {
  108|  21.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  21.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  21.2k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  21.2k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  21.2k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  21.2k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  21.2k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  21.2k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  21.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  21.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  21.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  21.2k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  21.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  21.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  21.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|  21.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  21.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  21.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  21.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  21.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 21.2k, False: 35]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  21.2k|            else if constexpr( has_apply0_bool ) {
  153|  21.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  21.2k|            }
  155|  21.2k|         }
  156|  21.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 21.2k, False: 35]
  ------------------
  157|  21.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  21.2k|         }
  159|     35|         else {
  160|     35|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     35|         }
  162|  21.2k|         (void)m( result );
  163|  21.2k|         return result;
  164|  21.2k|      }
  165|  21.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  21.2k|      {
   73|  21.2k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  21.2k|         else {
   84|  21.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  21.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  21.2k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  21.2k|      {
   44|  21.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  21.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  42.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.5k|      else {
  108|  42.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.5k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  42.5k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  42.5k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  42.5k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  42.5k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  42.5k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  42.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.5k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  42.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.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|  42.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.5k, False: 35]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  42.5k|            else if constexpr( has_apply0_bool ) {
  153|  42.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.5k|            }
  155|  42.5k|         }
  156|  42.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.5k, False: 35]
  ------------------
  157|  42.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.5k|         }
  159|     35|         else {
  160|     35|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     35|         }
  162|  42.5k|         (void)m( result );
  163|  42.5k|         return result;
  164|  42.5k|      }
  165|  42.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  42.5k|      {
   73|  42.5k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  42.5k|         else {
   84|  42.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.5k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  42.5k|      {
   59|  42.5k|         return Rule::match( in );
   60|  42.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  70.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  70.7k|      else {
  108|  70.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  70.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  70.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  70.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  70.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  70.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  70.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  70.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  70.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  70.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  70.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  70.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  70.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  70.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  70.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|  70.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  70.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  70.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  70.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  70.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.8k, False: 40.8k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.8k|            else if constexpr( has_apply0_bool ) {
  153|  29.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.8k|            }
  155|  29.8k|         }
  156|  70.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.8k, False: 40.8k]
  ------------------
  157|  29.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.8k|         }
  159|  40.8k|         else {
  160|  40.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  40.8k|         }
  162|  70.7k|         (void)m( result );
  163|  70.7k|         return result;
  164|  70.7k|      }
  165|  70.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  70.7k|      {
   73|  70.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  70.7k|         else {
   84|  70.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  70.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  70.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  70.7k|      {
   44|  70.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  70.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   104k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   104k|      else {
  108|   104k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   104k|         using iterator_t = typename ParseInput::iterator_t;
  111|   104k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   104k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   104k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   104k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   104k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   104k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   104k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   104k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   104k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   104k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   104k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   104k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   104k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   104k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   104k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   104k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   104k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   104k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 34.9k, False: 69.6k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  34.9k|            else if constexpr( has_apply0_bool ) {
  153|  34.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  34.9k|            }
  155|  34.9k|         }
  156|   104k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 34.9k, False: 69.6k]
  ------------------
  157|  34.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  34.9k|         }
  159|  69.6k|         else {
  160|  69.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  69.6k|         }
  162|   104k|         (void)m( result );
  163|   104k|         return result;
  164|   104k|      }
  165|   104k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   104k|      {
   73|   104k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   104k|         else {
   84|   104k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   104k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   104k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   104k|      {
   59|   104k|         return Rule::match( in );
   60|   104k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  29.8k|   {
  104|  29.8k|      if constexpr( !Control< Rule >::enable ) {
  105|  29.8k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  29.8k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  29.8k|      {
   44|  29.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.8k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  29.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  29.8k|      else {
  108|  29.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  29.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  29.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  29.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  29.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  29.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  29.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  29.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  29.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  29.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  29.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  29.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  29.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  29.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  29.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|  29.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  29.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  29.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  29.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  29.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.8k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.8k|            else if constexpr( has_apply0_bool ) {
  153|  29.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.8k|            }
  155|  29.8k|         }
  156|  29.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.8k, False: 0]
  ------------------
  157|  29.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.8k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  29.8k|         (void)m( result );
  163|  29.8k|         return result;
  164|  29.8k|      }
  165|  29.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  29.8k|      {
   73|  29.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  29.8k|         else {
   84|  29.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  29.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  29.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  29.8k|      {
   44|  29.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.8k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  40.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  40.8k|      else {
  108|  40.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  40.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  40.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  40.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  40.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  40.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  40.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  40.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  40.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  40.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  40.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  40.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  40.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  40.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  40.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|  40.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  40.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  40.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  40.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  40.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39.8k, False: 1.02k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  39.8k|            else if constexpr( has_apply0_bool ) {
  153|  39.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.8k|            }
  155|  39.8k|         }
  156|  40.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.8k, False: 1.02k]
  ------------------
  157|  39.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.8k|         }
  159|  1.02k|         else {
  160|  1.02k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.02k|         }
  162|  40.8k|         (void)m( result );
  163|  40.8k|         return result;
  164|  40.8k|      }
  165|  40.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  40.8k|      {
   73|  40.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  40.8k|         else {
   84|  40.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  40.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  40.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  40.8k|      {
   59|  40.8k|         return Rule::match( in );
   60|  40.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.02k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.02k|      else {
  108|  1.02k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.02k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.02k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.02k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.02k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.02k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.02k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.02k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.02k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.02k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.02k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.02k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.02k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.02k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.02k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.02k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.02k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.02k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.02k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 994, False: 34]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    994|            else if constexpr( has_apply0_bool ) {
  153|    994|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    994|            }
  155|    994|         }
  156|  1.02k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 994, False: 34]
  ------------------
  157|    994|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    994|         }
  159|     34|         else {
  160|     34|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     34|         }
  162|  1.02k|         (void)m( result );
  163|  1.02k|         return result;
  164|  1.02k|      }
  165|  1.02k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.02k|      {
   73|  1.02k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.02k|         else {
   84|  1.02k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.02k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.02k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.02k|      {
   59|  1.02k|         return Rule::match( in );
   60|  1.02k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.24M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.24M|      else {
  108|  7.24M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.24M|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.24M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  7.24M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.24M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.24M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.24M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.24M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  7.24M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.24M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.24M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.24M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  7.24M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.24M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.24M|         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.24M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.24M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.24M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.24M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.24M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.24M, False: 176]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  7.24M|            else if constexpr( has_apply0_bool ) {
  153|  7.24M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.24M|            }
  155|  7.24M|         }
  156|  7.24M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.24M, False: 176]
  ------------------
  157|  7.24M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.24M|         }
  159|    176|         else {
  160|    176|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    176|         }
  162|  7.24M|         (void)m( result );
  163|  7.24M|         return result;
  164|  7.24M|      }
  165|  7.24M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.24M|      {
   73|  7.24M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  7.24M|         else {
   84|  7.24M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.24M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.24M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.24M|      {
   59|  7.24M|         return Rule::match( in );
   60|  7.24M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser19condition_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  16.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.9k|      else {
  108|  16.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  16.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  16.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  16.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  16.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  16.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  16.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  16.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.85k, False: 14.0k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.85k|            else if constexpr( has_apply0_bool ) {
  153|  2.85k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.85k|            }
  155|  2.85k|         }
  156|  16.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.85k, False: 14.0k]
  ------------------
  157|  2.85k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.85k|         }
  159|  14.0k|         else {
  160|  14.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  14.0k|         }
  162|  16.9k|         (void)m( result );
  163|  16.9k|         return result;
  164|  16.9k|      }
  165|  16.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser19condition_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  16.9k|      {
   73|  16.9k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  16.9k|         else {
   84|  16.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser19condition_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  16.9k|      {
   44|  16.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  16.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  16.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.9k|      else {
  108|  16.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  16.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  16.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  16.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  16.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  16.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  16.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  16.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.85k, False: 14.0k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.85k|            else if constexpr( has_apply0_bool ) {
  153|  2.85k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.85k|            }
  155|  2.85k|         }
  156|  16.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.85k, False: 14.0k]
  ------------------
  157|  2.85k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.85k|         }
  159|  14.0k|         else {
  160|  14.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  14.0k|         }
  162|  16.9k|         (void)m( result );
  163|  16.9k|         return result;
  164|  16.9k|      }
  165|  16.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_6str_ifENS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  16.9k|      {
   73|  16.9k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  16.9k|         else {
   84|  16.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14rule_attributeINS4_6str_ifENS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  16.9k|      {
   44|  16.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  16.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6str_ifELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  16.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.9k|      else {
  108|  16.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  16.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  16.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 16.9k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  16.9k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  16.9k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  16.9k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  16.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  16.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 16.9k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.93k, False: 10.9k]
  ------------------
  143|  5.93k|            if constexpr( has_apply_void ) {
  144|  5.93k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  5.93k|         }
  156|  16.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.93k, False: 10.9k]
  ------------------
  157|  5.93k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.93k|         }
  159|  10.9k|         else {
  160|  10.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.9k|         }
  162|  16.9k|         (void)m( result );
  163|  16.9k|         return result;
  164|  16.9k|      }
  165|  16.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser6str_ifELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  16.9k|      {
   73|  16.9k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  16.9k|         else {
   84|  16.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser6str_ifELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  16.9k|      {
   59|  16.9k|         return Rule::match( in );
   60|  16.9k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   644k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   644k|      else {
  108|   644k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   644k|         using iterator_t = typename ParseInput::iterator_t;
  111|   644k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   644k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   644k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   644k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   644k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   644k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   644k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   644k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   644k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   644k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   644k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   644k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   644k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   644k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   644k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   644k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   644k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   644k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 642k, False: 2.10k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   642k|            else if constexpr( has_apply0_bool ) {
  153|   642k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   642k|            }
  155|   642k|         }
  156|   644k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 642k, False: 2.10k]
  ------------------
  157|   642k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   642k|         }
  159|  2.10k|         else {
  160|  2.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.10k|         }
  162|   644k|         (void)m( result );
  163|   644k|         return result;
  164|   644k|      }
  165|   644k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|   644k|      {
   73|   644k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   644k|         else {
   84|   644k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   644k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   644k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   644k|      {
   44|   644k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   644k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   644k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   644k|      else {
  108|   644k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   644k|         using iterator_t = typename ParseInput::iterator_t;
  111|   644k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   644k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   644k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   644k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   644k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   644k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   644k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   644k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   644k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   644k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   644k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   644k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   644k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   644k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   644k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   644k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   644k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   644k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 642k, False: 2.10k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   642k|            else if constexpr( has_apply0_bool ) {
  153|   642k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   642k|            }
  155|   642k|         }
  156|   644k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 642k, False: 2.10k]
  ------------------
  157|   642k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   642k|         }
  159|  2.10k|         else {
  160|  2.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.10k|         }
  162|   644k|         (void)m( result );
  163|   644k|         return result;
  164|   644k|      }
  165|   644k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   644k|      {
   73|   644k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   644k|         else {
   84|   644k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   644k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   644k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   644k|      {
   59|   644k|         return Rule::match( in );
   60|   644k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   679k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   679k|      else {
  108|   679k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   679k|         using iterator_t = typename ParseInput::iterator_t;
  111|   679k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   679k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   679k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   679k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   679k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   679k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   679k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   679k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   679k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   679k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   679k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   679k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   679k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   679k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   679k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   679k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   679k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   679k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.4k, False: 648k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  30.4k|            else if constexpr( has_apply0_bool ) {
  153|  30.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.4k|            }
  155|  30.4k|         }
  156|   679k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.4k, False: 648k]
  ------------------
  157|  30.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.4k|         }
  159|   648k|         else {
  160|   648k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   648k|         }
  162|   679k|         (void)m( result );
  163|   679k|         return result;
  164|   679k|      }
  165|   679k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   679k|      {
   73|   679k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   679k|         else {
   84|   679k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   679k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   679k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   679k|      {
   59|   679k|         return Rule::match( in );
   60|   679k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  5.90k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.90k|      else {
  108|  5.90k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.90k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.90k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.90k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.90k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.90k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.90k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.90k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.90k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.90k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.90k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.90k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.90k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.90k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.90k|         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.90k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.90k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.90k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.90k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.90k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.85k, False: 3.05k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.85k|            else if constexpr( has_apply0_bool ) {
  153|  2.85k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.85k|            }
  155|  2.85k|         }
  156|  5.90k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.85k, False: 3.05k]
  ------------------
  157|  2.85k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.85k|         }
  159|  3.05k|         else {
  160|  3.05k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.05k|         }
  162|  5.90k|         (void)m( result );
  163|  5.90k|         return result;
  164|  5.90k|      }
  165|  5.90k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_9conditionEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  5.90k|      {
   73|  5.90k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.90k|         else {
   84|  5.90k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.90k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.90k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_9conditionEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.90k|      {
   44|  5.90k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.90k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.90k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.90k|      else {
  108|  5.90k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.90k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.90k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.90k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.90k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.90k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.90k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.90k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.90k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.90k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.90k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.90k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.90k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.90k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.90k|         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.90k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.90k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.90k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.90k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.90k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.86k, False: 4.03k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  5.90k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.86k, False: 4.03k]
  ------------------
  157|  1.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.86k|         }
  159|  4.03k|         else {
  160|  4.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.03k|         }
  162|  5.90k|         (void)m( result );
  163|  5.90k|         return result;
  164|  5.90k|      }
  165|  5.90k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.90k|      {
   73|  5.90k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.90k|         else {
   84|  5.90k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.90k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.90k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.90k|      {
   44|  5.90k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.90k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  5.90k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.90k|      else {
  108|  5.90k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.90k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.90k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.90k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.90k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.90k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.90k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.90k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.90k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.90k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.90k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.90k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.90k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.90k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.90k|         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.90k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.90k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.90k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.90k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.90k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.90k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.90k|            else if constexpr( has_apply0_bool ) {
  153|  5.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.90k|            }
  155|  5.90k|         }
  156|  5.90k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.90k, False: 0]
  ------------------
  157|  5.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.90k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  5.90k|         (void)m( result );
  163|  5.90k|         return result;
  164|  5.90k|      }
  165|  5.90k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  5.90k|      {
   73|  5.90k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.90k|         else {
   84|  5.90k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.90k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.90k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.90k|      {
   44|  5.90k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.90k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  5.90k|   {
  104|  5.90k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.90k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  5.90k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.90k|      {
   44|  5.90k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.90k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.90k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.90k|      else {
  108|  5.90k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.90k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.90k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  5.90k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.90k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 5.90k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.90k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.90k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.90k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.90k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.90k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.90k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.90k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.90k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.90k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.90k|         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.90k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 5.90k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.90k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.90k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.90k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.90k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.28k, False: 4.61k]
  ------------------
  143|  1.28k|            if constexpr( has_apply_void ) {
  144|  1.28k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.28k|         }
  156|  5.90k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.28k, False: 4.61k]
  ------------------
  157|  1.28k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.28k|         }
  159|  4.61k|         else {
  160|  4.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.61k|         }
  162|  5.90k|         (void)m( result );
  163|  5.90k|         return result;
  164|  5.90k|      }
  165|  5.90k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.90k|      {
   73|  5.90k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.90k|         else {
   84|  5.90k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.90k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.90k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  5.90k|      {
   44|  5.90k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.90k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.90k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.90k|      else {
  108|  5.90k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.90k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.90k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.90k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.90k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.90k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.90k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.90k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.90k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.90k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.90k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.90k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.90k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.90k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.90k|         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.90k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.90k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.90k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.90k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.90k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 76, False: 5.82k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|     76|            else if constexpr( has_apply0_bool ) {
  153|     76|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     76|            }
  155|     76|         }
  156|  5.90k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 76, False: 5.82k]
  ------------------
  157|     76|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     76|         }
  159|  5.82k|         else {
  160|  5.82k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.82k|         }
  162|  5.90k|         (void)m( result );
  163|  5.90k|         return result;
  164|  5.90k|      }
  165|  5.90k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.90k|      {
   73|  5.90k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.90k|         else {
   84|  5.90k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.90k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.90k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.90k|      {
   59|  5.90k|         return Rule::match( in );
   60|  5.90k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.82k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.82k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.82k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.82k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.82k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 215, False: 5.61k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    215|            else if constexpr( has_apply0_bool ) {
  153|    215|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    215|            }
  155|    215|         }
  156|  5.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 215, False: 5.61k]
  ------------------
  157|    215|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    215|         }
  159|  5.61k|         else {
  160|  5.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.61k|         }
  162|  5.82k|         (void)m( result );
  163|  5.82k|         return result;
  164|  5.82k|      }
  165|  5.82k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.61k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.61k|      else {
  108|  5.61k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.61k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.61k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.61k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.61k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.61k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.61k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.61k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.61k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.61k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.61k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.61k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.61k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.61k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.61k|         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.61k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.61k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.61k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.61k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.61k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 224, False: 5.39k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    224|            else if constexpr( has_apply0_bool ) {
  153|    224|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    224|            }
  155|    224|         }
  156|  5.61k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 224, False: 5.39k]
  ------------------
  157|    224|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    224|         }
  159|  5.39k|         else {
  160|  5.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.39k|         }
  162|  5.61k|         (void)m( result );
  163|  5.61k|         return result;
  164|  5.61k|      }
  165|  5.61k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.61k|      {
   73|  5.61k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.61k|         else {
   84|  5.61k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.61k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.61k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.61k|      {
   59|  5.61k|         return Rule::match( in );
   60|  5.61k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.39k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.39k|      else {
  108|  5.39k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.39k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.39k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.39k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.39k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.39k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.39k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.39k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.39k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.39k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.39k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.39k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.39k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.39k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.39k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.39k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.39k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.39k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.39k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 296, False: 5.09k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    296|            else if constexpr( has_apply0_bool ) {
  153|    296|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    296|            }
  155|    296|         }
  156|  5.39k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 296, False: 5.09k]
  ------------------
  157|    296|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    296|         }
  159|  5.09k|         else {
  160|  5.09k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.09k|         }
  162|  5.39k|         (void)m( result );
  163|  5.39k|         return result;
  164|  5.39k|      }
  165|  5.39k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.39k|      {
   73|  5.39k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.39k|         else {
   84|  5.39k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.39k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.39k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.39k|      {
   59|  5.39k|         return Rule::match( in );
   60|  5.39k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.09k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.09k|      else {
  108|  5.09k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.09k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.09k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.09k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.09k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.09k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.09k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.09k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.09k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.09k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.09k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.09k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.09k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.09k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.09k|         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.09k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.09k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.09k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.09k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.09k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 275, False: 4.81k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    275|            else if constexpr( has_apply0_bool ) {
  153|    275|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    275|            }
  155|    275|         }
  156|  5.09k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 275, False: 4.81k]
  ------------------
  157|    275|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    275|         }
  159|  4.81k|         else {
  160|  4.81k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.81k|         }
  162|  5.09k|         (void)m( result );
  163|  5.09k|         return result;
  164|  5.09k|      }
  165|  5.09k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  5.09k|      {
   73|  5.09k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.09k|         else {
   84|  5.09k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.09k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.09k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.09k|      {
   59|  5.09k|         return Rule::match( in );
   60|  5.09k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.81k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.81k|      else {
  108|  4.81k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.81k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.81k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.81k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.81k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.81k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.81k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.81k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.81k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.81k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.81k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.81k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.81k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.81k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.81k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.81k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.81k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.81k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.81k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 203, False: 4.61k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    203|            else if constexpr( has_apply0_bool ) {
  153|    203|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    203|            }
  155|    203|         }
  156|  4.81k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 203, False: 4.61k]
  ------------------
  157|    203|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    203|         }
  159|  4.61k|         else {
  160|  4.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.61k|         }
  162|  4.81k|         (void)m( result );
  163|  4.81k|         return result;
  164|  4.81k|      }
  165|  4.81k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.81k|      {
   73|  4.81k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.81k|         else {
   84|  4.81k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.81k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.81k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.81k|      {
   59|  4.81k|         return Rule::match( in );
   60|  4.81k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.90k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.90k|      else {
  108|  5.90k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.90k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.90k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.90k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.90k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.90k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  5.90k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  5.90k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  5.90k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.90k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.90k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.90k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  5.90k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.90k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.90k|         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.90k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.90k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.90k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.90k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.90k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.73k, False: 2.17k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.73k|            else if constexpr( has_apply0_bool ) {
  153|  3.73k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.73k|            }
  155|  3.73k|         }
  156|  5.90k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.73k, False: 2.17k]
  ------------------
  157|  3.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.73k|         }
  159|  2.17k|         else {
  160|  2.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.17k|         }
  162|  5.90k|         (void)m( result );
  163|  5.90k|         return result;
  164|  5.90k|      }
  165|  5.90k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  5.90k|      {
   73|  5.90k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  5.90k|         else {
   84|  5.90k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.90k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.90k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  5.90k|      {
   59|  5.90k|         return Rule::match( in );
   60|  5.90k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.21k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.21k|      else {
  108|  6.21k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.21k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.21k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.21k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.21k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.21k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.21k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.21k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.21k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.21k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.21k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.21k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.21k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.21k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.21k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.21k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.21k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.21k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.21k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.21k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  6.21k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.21k, False: 0]
  ------------------
  157|  6.21k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.21k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.21k|         (void)m( result );
  163|  6.21k|         return result;
  164|  6.21k|      }
  165|  6.21k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  6.21k|      {
   73|  6.21k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.21k|         else {
   84|  6.21k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.21k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.21k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.21k|      {
   44|  6.21k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.21k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  3.73k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.73k|      else {
  108|  3.73k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.73k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.73k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.73k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.73k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.73k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.73k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.73k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.73k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.73k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.73k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.73k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.73k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.73k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.73k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.73k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.73k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.73k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.73k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.48k, False: 1.25k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.48k|            else if constexpr( has_apply0_bool ) {
  153|  2.48k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.48k|            }
  155|  2.48k|         }
  156|  3.73k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.48k, False: 1.25k]
  ------------------
  157|  2.48k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.48k|         }
  159|  1.25k|         else {
  160|  1.25k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.25k|         }
  162|  3.73k|         (void)m( result );
  163|  3.73k|         return result;
  164|  3.73k|      }
  165|  3.73k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  3.73k|      {
   73|  3.73k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.73k|         else {
   84|  3.73k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.73k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.73k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.73k|      {
   44|  3.73k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.73k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser9conditionEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.59k|   {
  104|  3.59k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.59k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  3.59k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser9conditionEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  3.59k|      {
   44|  3.59k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.59k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   637k|   {
  104|   637k|      if constexpr( !Control< Rule >::enable ) {
  105|   637k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   637k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   637k|      {
   44|   637k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   637k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.48k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.48k|      else {
  108|  2.48k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.48k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.48k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.48k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.48k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.48k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.48k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.48k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.48k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.48k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.48k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.48k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.48k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.48k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.48k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.48k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.48k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.48k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.48k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.86k, False: 615]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  2.48k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.86k, False: 615]
  ------------------
  157|  1.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.86k|         }
  159|    615|         else {
  160|    615|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    615|         }
  162|  2.48k|         (void)m( result );
  163|  2.48k|         return result;
  164|  2.48k|      }
  165|  2.48k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.48k|      {
   73|  2.48k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.48k|         else {
   84|  2.48k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.48k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.48k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.48k|      {
   59|  2.48k|         return Rule::match( in );
   60|  2.48k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   641k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   641k|      else {
  108|   641k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   641k|         using iterator_t = typename ParseInput::iterator_t;
  111|   641k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|   641k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   641k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 641k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   641k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   641k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   641k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   641k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   641k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   641k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   641k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   641k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   641k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   641k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   641k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 641k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   641k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   641k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   641k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   641k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 640k, False: 1.61k]
  ------------------
  143|   640k|            if constexpr( has_apply_void ) {
  144|   640k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|   640k|         }
  156|   641k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 638k, False: 3.58k]
  ------------------
  157|   638k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   638k|         }
  159|  3.58k|         else {
  160|  3.58k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.58k|         }
  162|   641k|         (void)m( result );
  163|   641k|         return result;
  164|   641k|      }
  165|   641k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   641k|      {
   73|   641k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   641k|         else {
   84|   641k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   641k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   641k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   641k|      {
   44|   641k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   641k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser8negationEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   641k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   641k|      else {
  108|   641k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   641k|         using iterator_t = typename ParseInput::iterator_t;
  111|   641k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   641k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   641k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   641k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   641k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   641k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   641k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   641k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   641k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   641k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   641k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   641k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   641k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   641k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   641k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   641k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   641k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   641k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 641k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   641k|            else if constexpr( has_apply0_bool ) {
  153|   641k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   641k|            }
  155|   641k|         }
  156|   641k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 641k, False: 0]
  ------------------
  157|   641k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   641k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   641k|         (void)m( result );
  163|   641k|         return result;
  164|   641k|      }
  165|   641k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser8negationEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   641k|      {
   73|   641k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   641k|         else {
   84|   641k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   641k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   641k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser8negationEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   641k|      {
   44|   641k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   641k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   641k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   641k|      else {
  108|   641k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   641k|         using iterator_t = typename ParseInput::iterator_t;
  111|   641k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   641k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   641k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   641k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   641k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   641k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   641k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   641k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   641k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   641k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   641k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   641k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   641k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   641k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   641k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   641k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   641k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   641k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 505, False: 641k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    505|            else if constexpr( has_apply0_bool ) {
  153|    505|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    505|            }
  155|    505|         }
  156|   641k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 505, False: 641k]
  ------------------
  157|    505|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    505|         }
  159|   641k|         else {
  160|   641k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   641k|         }
  162|   641k|         (void)m( result );
  163|   641k|         return result;
  164|   641k|      }
  165|   641k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   641k|      {
   73|   641k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   641k|         else {
   84|   641k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   641k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   641k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   641k|      {
   59|   641k|         return Rule::match( in );
   60|   641k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser20condition_identifierELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   641k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   641k|      else {
  108|   641k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   641k|         using iterator_t = typename ParseInput::iterator_t;
  111|   641k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   641k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   641k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   641k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   641k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   641k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   641k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   641k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   641k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   641k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   641k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   641k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   641k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   641k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   641k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   641k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   641k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   641k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 640k, False: 1.25k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   640k|            else if constexpr( has_apply0_bool ) {
  153|   640k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   640k|            }
  155|   640k|         }
  156|   641k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 640k, False: 1.25k]
  ------------------
  157|   640k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   640k|         }
  159|  1.25k|         else {
  160|  1.25k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.25k|         }
  162|   641k|         (void)m( result );
  163|   641k|         return result;
  164|   641k|      }
  165|   641k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser20condition_identifierELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   641k|      {
   73|   641k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   641k|         else {
   84|   641k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   641k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   641k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser20condition_identifierELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   641k|      {
   44|   641k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   641k|      }
_ZN3tao5pegtl5matchINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   641k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   641k|      else {
  108|   641k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   641k|         using iterator_t = typename ParseInput::iterator_t;
  111|   641k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   641k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   641k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   641k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   641k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   641k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   641k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   641k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   641k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   641k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   641k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   641k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   641k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   641k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   641k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   641k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   641k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   641k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 640k, False: 1.25k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   640k|            else if constexpr( has_apply0_bool ) {
  153|   640k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   640k|            }
  155|   640k|         }
  156|   641k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 640k, False: 1.25k]
  ------------------
  157|   640k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   640k|         }
  159|  1.25k|         else {
  160|  1.25k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.25k|         }
  162|   641k|         (void)m( result );
  163|   641k|         return result;
  164|   641k|      }
  165|   641k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   641k|      {
   73|   641k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   641k|         else {
   84|   641k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   641k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   641k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   641k|      {
   59|   641k|         return Rule::match( in );
   60|   641k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
  103|   640k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   640k|      else {
  108|   640k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   640k|         using iterator_t = typename ParseInput::iterator_t;
  111|   640k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   640k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   640k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   640k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   640k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   640k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   640k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   640k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   640k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   640k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   640k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   640k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   640k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   640k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   640k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   640k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   640k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   640k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 640k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   640k|            else if constexpr( has_apply0_bool ) {
  153|   640k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   640k|            }
  155|   640k|         }
  156|   640k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 640k, False: 0]
  ------------------
  157|   640k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   640k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   640k|         (void)m( result );
  163|   640k|         return result;
  164|   640k|      }
  165|   640k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSA_4RuleEEEEDaRT4_DpOT5_:
   72|   640k|      {
   73|   640k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   640k|         else {
   84|   640k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   640k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   640k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSA_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   640k|      {
   44|   640k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   640k|      }
_ZN3tao5pegtl5matchINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  29.4M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  29.4M|      else {
  108|  29.4M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  29.4M|         using iterator_t = typename ParseInput::iterator_t;
  111|  29.4M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  29.4M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  29.4M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  29.4M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  29.4M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  29.4M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  29.4M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  29.4M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  29.4M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  29.4M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  29.4M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  29.4M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  29.4M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  29.4M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  29.4M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  29.4M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  29.4M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  29.4M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 28.8M, False: 640k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  28.8M|            else if constexpr( has_apply0_bool ) {
  153|  28.8M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  28.8M|            }
  155|  28.8M|         }
  156|  29.4M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 28.8M, False: 640k]
  ------------------
  157|  28.8M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  28.8M|         }
  159|   640k|         else {
  160|   640k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   640k|         }
  162|  29.4M|         (void)m( result );
  163|  29.4M|         return result;
  164|  29.4M|      }
  165|  29.4M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  29.4M|      {
   73|  29.4M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  29.4M|         else {
   84|  29.4M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  29.4M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  29.4M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  29.4M|      {
   59|  29.4M|         return Rule::match( in );
   60|  29.4M|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   640k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   640k|      else {
  108|   640k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   640k|         using iterator_t = typename ParseInput::iterator_t;
  111|   640k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   640k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   640k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   640k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   640k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   640k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   640k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   640k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   640k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   640k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   640k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   640k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   640k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   640k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   640k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   640k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   640k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   640k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 640k, False: 358]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   640k|            else if constexpr( has_apply0_bool ) {
  153|   640k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   640k|            }
  155|   640k|         }
  156|   640k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 640k, False: 358]
  ------------------
  157|   640k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   640k|         }
  159|    358|         else {
  160|    358|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    358|         }
  162|   640k|         (void)m( result );
  163|   640k|         return result;
  164|   640k|      }
  165|   640k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   640k|      {
   73|   640k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   640k|         else {
   84|   640k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   640k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   640k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   640k|      {
   44|   640k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   640k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18condition_argumentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   640k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   640k|      else {
  108|   640k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   640k|         using iterator_t = typename ParseInput::iterator_t;
  111|   640k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   640k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   640k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   640k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   640k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   640k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   640k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   640k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   640k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   640k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   640k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   640k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   640k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   640k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   640k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   640k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   640k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   640k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.0k, False: 605k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  35.0k|            else if constexpr( has_apply0_bool ) {
  153|  35.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.0k|            }
  155|  35.0k|         }
  156|   640k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.0k, False: 605k]
  ------------------
  157|  35.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.0k|         }
  159|   605k|         else {
  160|   605k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   605k|         }
  162|   640k|         (void)m( result );
  163|   640k|         return result;
  164|   640k|      }
  165|   640k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18condition_argumentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   640k|      {
   73|   640k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   640k|         else {
   84|   640k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   640k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   640k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18condition_argumentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   640k|      {
   44|   640k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   640k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   640k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   640k|      else {
  108|   640k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   640k|         using iterator_t = typename ParseInput::iterator_t;
  111|   640k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   640k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   640k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   640k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   640k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   640k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   640k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   640k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   640k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   640k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   640k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   640k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   640k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   640k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   640k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   640k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   640k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   640k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.4k, False: 605k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  35.4k|            else if constexpr( has_apply0_bool ) {
  153|  35.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.4k|            }
  155|  35.4k|         }
  156|   640k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.4k, False: 605k]
  ------------------
  157|  35.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.4k|         }
  159|   605k|         else {
  160|   605k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   605k|         }
  162|   640k|         (void)m( result );
  163|   640k|         return result;
  164|   640k|      }
  165|   640k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   640k|      {
   73|   640k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   640k|         else {
   84|   640k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   640k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   640k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   640k|      {
   59|   640k|         return Rule::match( in );
   60|   640k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  35.4k|   {
  104|  35.4k|      if constexpr( !Control< Rule >::enable ) {
  105|  35.4k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  35.4k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  35.4k|      {
   44|  35.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  35.4k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  35.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  35.4k|      else {
  108|  35.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  35.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  35.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  35.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  35.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  35.4k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  35.4k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  35.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  35.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  35.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  35.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  35.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  35.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  35.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  35.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|  35.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  35.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  35.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  35.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  35.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.0k, False: 358]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  35.0k|            else if constexpr( has_apply0_bool ) {
  153|  35.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.0k|            }
  155|  35.0k|         }
  156|  35.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.0k, False: 358]
  ------------------
  157|  35.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.0k|         }
  159|    358|         else {
  160|    358|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    358|         }
  162|  35.4k|         (void)m( result );
  163|  35.4k|         return result;
  164|  35.4k|      }
  165|  35.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  35.4k|      {
   73|  35.4k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  35.4k|         else {
   84|  35.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  35.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  35.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  35.4k|      {
   44|  35.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  35.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  44.7M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.7M|      else {
  108|  44.7M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.7M|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.7M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  44.7M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  44.7M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  44.7M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  44.7M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  44.7M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  44.7M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.7M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.7M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.7M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  44.7M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.7M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.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|  44.7M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.7M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.7M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.7M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.7M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.0k, False: 44.7M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  35.0k|            else if constexpr( has_apply0_bool ) {
  153|  35.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.0k|            }
  155|  35.0k|         }
  156|  44.7M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.0k, False: 44.7M]
  ------------------
  157|  35.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.0k|         }
  159|  44.7M|         else {
  160|  44.7M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  44.7M|         }
  162|  44.7M|         (void)m( result );
  163|  44.7M|         return result;
  164|  44.7M|      }
  165|  44.7M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  44.7M|      {
   73|  44.7M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  44.7M|         else {
   84|  44.7M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.7M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.7M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  44.7M|      {
   59|  44.7M|         return Rule::match( in );
   60|  44.7M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  44.7M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.7M|      else {
  108|  44.7M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.7M|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.7M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  44.7M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  44.7M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  44.7M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  44.7M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  44.7M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  44.7M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.7M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.7M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.7M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  44.7M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.7M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.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|  44.7M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.7M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.7M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.7M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.7M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44.7M, False: 358]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  44.7M|            else if constexpr( has_apply0_bool ) {
  153|  44.7M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.7M|            }
  155|  44.7M|         }
  156|  44.7M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.7M, False: 358]
  ------------------
  157|  44.7M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.7M|         }
  159|    358|         else {
  160|    358|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    358|         }
  162|  44.7M|         (void)m( result );
  163|  44.7M|         return result;
  164|  44.7M|      }
  165|  44.7M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  44.7M|      {
   73|  44.7M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  44.7M|         else {
   84|  44.7M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.7M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.7M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  44.7M|      {
   44|  44.7M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.7M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  44.7M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.7M|      else {
  108|  44.7M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.7M|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.7M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  44.7M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  44.7M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  44.7M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  44.7M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  44.7M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  44.7M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.7M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.7M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.7M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  44.7M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.7M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.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|  44.7M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.7M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.7M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.7M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.7M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 174k, False: 44.5M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   174k|            else if constexpr( has_apply0_bool ) {
  153|   174k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   174k|            }
  155|   174k|         }
  156|  44.7M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 174k, False: 44.5M]
  ------------------
  157|   174k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   174k|         }
  159|  44.5M|         else {
  160|  44.5M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  44.5M|         }
  162|  44.7M|         (void)m( result );
  163|  44.7M|         return result;
  164|  44.7M|      }
  165|  44.7M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  44.7M|      {
   73|  44.7M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  44.7M|         else {
   84|  44.7M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.7M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.7M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  44.7M|      {
   44|  44.7M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.7M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  44.7M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.7M|      else {
  108|  44.7M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.7M|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.7M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  44.7M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  44.7M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  44.7M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  44.7M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  44.7M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  44.7M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.7M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.7M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.7M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  44.7M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.7M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.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|  44.7M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.7M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.7M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.7M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.7M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 174k, False: 44.5M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   174k|            else if constexpr( has_apply0_bool ) {
  153|   174k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   174k|            }
  155|   174k|         }
  156|  44.7M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 174k, False: 44.5M]
  ------------------
  157|   174k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   174k|         }
  159|  44.5M|         else {
  160|  44.5M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  44.5M|         }
  162|  44.7M|         (void)m( result );
  163|  44.7M|         return result;
  164|  44.7M|      }
  165|  44.7M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  44.7M|      {
   73|  44.7M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  44.7M|         else {
   84|  44.7M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.7M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.7M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  44.7M|      {
   59|  44.7M|         return Rule::match( in );
   60|  44.7M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   174k|   {
  104|   174k|      if constexpr( !Control< Rule >::enable ) {
  105|   174k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   174k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   174k|      {
   44|   174k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   174k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   174k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   174k|      else {
  108|   174k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   174k|         using iterator_t = typename ParseInput::iterator_t;
  111|   174k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   174k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   174k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   174k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   174k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   174k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   174k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   174k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   174k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   174k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   174k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   174k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   174k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   174k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   174k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   174k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   174k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   174k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 174k, False: 103]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   174k|            else if constexpr( has_apply0_bool ) {
  153|   174k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   174k|            }
  155|   174k|         }
  156|   174k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 174k, False: 103]
  ------------------
  157|   174k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   174k|         }
  159|    103|         else {
  160|    103|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    103|         }
  162|   174k|         (void)m( result );
  163|   174k|         return result;
  164|   174k|      }
  165|   174k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   174k|      {
   73|   174k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   174k|         else {
   84|   174k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   174k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   174k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   174k|      {
   44|   174k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   174k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   174k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   174k|      else {
  108|   174k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   174k|         using iterator_t = typename ParseInput::iterator_t;
  111|   174k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   174k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   174k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   174k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   174k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   174k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   174k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   174k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   174k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   174k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   174k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   174k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   174k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   174k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   174k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   174k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   174k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   174k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.0k, False: 145k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.0k|            else if constexpr( has_apply0_bool ) {
  153|  29.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.0k|            }
  155|  29.0k|         }
  156|   174k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.0k, False: 145k]
  ------------------
  157|  29.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.0k|         }
  159|   145k|         else {
  160|   145k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   145k|         }
  162|   174k|         (void)m( result );
  163|   174k|         return result;
  164|   174k|      }
  165|   174k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   174k|      {
   73|   174k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   174k|         else {
   84|   174k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   174k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   174k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   174k|      {
   44|   174k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   174k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   174k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   174k|      else {
  108|   174k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   174k|         using iterator_t = typename ParseInput::iterator_t;
  111|   174k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   174k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   174k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   174k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   174k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   174k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   174k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   174k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   174k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   174k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   174k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   174k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   174k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   174k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   174k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   174k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   174k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   174k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.0k, False: 145k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.0k|            else if constexpr( has_apply0_bool ) {
  153|  29.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.0k|            }
  155|  29.0k|         }
  156|   174k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.0k, False: 145k]
  ------------------
  157|  29.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.0k|         }
  159|   145k|         else {
  160|   145k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   145k|         }
  162|   174k|         (void)m( result );
  163|   174k|         return result;
  164|   174k|      }
  165|   174k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   174k|      {
   73|   174k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   174k|         else {
   84|   174k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   174k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   174k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   174k|      {
   59|   174k|         return Rule::match( in );
   60|   174k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  29.0k|   {
  104|  29.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  29.0k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  29.0k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  29.0k|      {
   44|  29.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.0k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  29.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  29.0k|      else {
  108|  29.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  29.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  29.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  29.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  29.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  29.0k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  29.0k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  29.0k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  29.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  29.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  29.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  29.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  29.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  29.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  29.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|  29.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  29.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  29.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  29.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  29.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.0k, False: 41]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.0k|            else if constexpr( has_apply0_bool ) {
  153|  29.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.0k|            }
  155|  29.0k|         }
  156|  29.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.0k, False: 41]
  ------------------
  157|  29.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.0k|         }
  159|     41|         else {
  160|     41|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     41|         }
  162|  29.0k|         (void)m( result );
  163|  29.0k|         return result;
  164|  29.0k|      }
  165|  29.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  29.0k|      {
   73|  29.0k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  29.0k|         else {
   84|  29.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  29.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  29.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  29.0k|      {
   44|  29.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  58.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  58.1k|      else {
  108|  58.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  58.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  58.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  58.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  58.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  58.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  58.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  58.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  58.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  58.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  58.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  58.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  58.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  58.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  58.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|  58.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  58.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  58.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  58.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  58.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 58.0k, False: 41]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  58.0k|            else if constexpr( has_apply0_bool ) {
  153|  58.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  58.0k|            }
  155|  58.0k|         }
  156|  58.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 58.0k, False: 41]
  ------------------
  157|  58.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  58.0k|         }
  159|     41|         else {
  160|     41|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     41|         }
  162|  58.1k|         (void)m( result );
  163|  58.1k|         return result;
  164|  58.1k|      }
  165|  58.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  58.1k|      {
   73|  58.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  58.1k|         else {
   84|  58.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  58.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  58.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  58.1k|      {
   59|  58.1k|         return Rule::match( in );
   60|  58.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   145k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   145k|      else {
  108|   145k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   145k|         using iterator_t = typename ParseInput::iterator_t;
  111|   145k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   145k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   145k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   145k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   145k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   145k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   145k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   145k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   145k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   145k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   145k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   145k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   145k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   145k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   145k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   145k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   145k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   145k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.1k, False: 116k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.1k|            else if constexpr( has_apply0_bool ) {
  153|  29.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.1k|            }
  155|  29.1k|         }
  156|   145k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.1k, False: 116k]
  ------------------
  157|  29.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.1k|         }
  159|   116k|         else {
  160|   116k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   116k|         }
  162|   145k|         (void)m( result );
  163|   145k|         return result;
  164|   145k|      }
  165|   145k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   145k|      {
   73|   145k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   145k|         else {
   84|   145k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   145k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   145k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   145k|      {
   44|   145k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   145k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   181k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   181k|      else {
  108|   181k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   181k|         using iterator_t = typename ParseInput::iterator_t;
  111|   181k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   181k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   181k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   181k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   181k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   181k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   181k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   181k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   181k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   181k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   181k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   181k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   181k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   181k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   181k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   181k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   181k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   181k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.6k, False: 143k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  37.6k|            else if constexpr( has_apply0_bool ) {
  153|  37.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.6k|            }
  155|  37.6k|         }
  156|   181k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.6k, False: 143k]
  ------------------
  157|  37.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.6k|         }
  159|   143k|         else {
  160|   143k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   143k|         }
  162|   181k|         (void)m( result );
  163|   181k|         return result;
  164|   181k|      }
  165|   181k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   181k|      {
   73|   181k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   181k|         else {
   84|   181k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   181k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   181k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   181k|      {
   59|   181k|         return Rule::match( in );
   60|   181k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  29.1k|   {
  104|  29.1k|      if constexpr( !Control< Rule >::enable ) {
  105|  29.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  29.1k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  29.1k|      {
   44|  29.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.1k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  29.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  29.1k|      else {
  108|  29.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  29.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  29.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  29.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  29.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  29.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  29.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  29.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  29.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  29.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  29.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  29.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  29.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  29.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  29.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|  29.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  29.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  29.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  29.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  29.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.1k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.1k|            else if constexpr( has_apply0_bool ) {
  153|  29.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.1k|            }
  155|  29.1k|         }
  156|  29.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.1k, False: 0]
  ------------------
  157|  29.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.1k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  29.1k|         (void)m( result );
  163|  29.1k|         return result;
  164|  29.1k|      }
  165|  29.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  29.1k|      {
   73|  29.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  29.1k|         else {
   84|  29.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  29.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  29.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  29.1k|      {
   44|  29.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   116k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   116k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   116k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   116k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   116k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 115k, False: 593]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   115k|            else if constexpr( has_apply0_bool ) {
  153|   115k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   115k|            }
  155|   115k|         }
  156|   116k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 115k, False: 593]
  ------------------
  157|   115k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   115k|         }
  159|    593|         else {
  160|    593|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    593|         }
  162|   116k|         (void)m( result );
  163|   116k|         return result;
  164|   116k|      }
  165|   116k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   116k|      {
   73|   116k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   116k|      {
   59|   116k|         return Rule::match( in );
   60|   116k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    593|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    593|      else {
  108|    593|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    593|         using iterator_t = typename ParseInput::iterator_t;
  111|    593|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    593|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    593|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    593|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    593|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    593|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    593|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    593|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    593|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    593|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    593|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    593|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    593|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    593|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    593|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    593|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    593|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    593|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 531, False: 62]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    531|            else if constexpr( has_apply0_bool ) {
  153|    531|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    531|            }
  155|    531|         }
  156|    593|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 531, False: 62]
  ------------------
  157|    531|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    531|         }
  159|     62|         else {
  160|     62|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     62|         }
  162|    593|         (void)m( result );
  163|    593|         return result;
  164|    593|      }
  165|    593|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    593|      {
   73|    593|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    593|         else {
   84|    593|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    593|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    593|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|    593|      {
   59|    593|         return Rule::match( in );
   60|    593|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  44.5M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.5M|      else {
  108|  44.5M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.5M|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.5M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  44.5M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  44.5M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  44.5M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  44.5M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  44.5M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  44.5M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.5M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.5M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.5M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  44.5M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.5M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.5M|         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.5M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.5M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.5M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.5M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.5M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 44.5M, False: 255]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  44.5M|            else if constexpr( has_apply0_bool ) {
  153|  44.5M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.5M|            }
  155|  44.5M|         }
  156|  44.5M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.5M, False: 255]
  ------------------
  157|  44.5M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.5M|         }
  159|    255|         else {
  160|    255|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    255|         }
  162|  44.5M|         (void)m( result );
  163|  44.5M|         return result;
  164|  44.5M|      }
  165|  44.5M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  44.5M|      {
   73|  44.5M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  44.5M|         else {
   84|  44.5M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.5M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.5M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  44.5M|      {
   59|  44.5M|         return Rule::match( in );
   60|  44.5M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15label_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  11.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  11.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  11.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  11.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  11.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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.53k, False: 8.20k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.53k|            else if constexpr( has_apply0_bool ) {
  153|  3.53k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.53k|            }
  155|  3.53k|         }
  156|  11.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.53k, False: 8.20k]
  ------------------
  157|  3.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.53k|         }
  159|  8.20k|         else {
  160|  8.20k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.20k|         }
  162|  11.7k|         (void)m( result );
  163|  11.7k|         return result;
  164|  11.7k|      }
  165|  11.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15label_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser15label_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  11.7k|      {
   44|  11.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  11.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  11.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  11.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  11.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  11.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  11.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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.53k, False: 8.20k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.53k|            else if constexpr( has_apply0_bool ) {
  153|  3.53k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.53k|            }
  155|  3.53k|         }
  156|  11.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.53k, False: 8.20k]
  ------------------
  157|  3.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.53k|         }
  159|  8.20k|         else {
  160|  8.20k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.20k|         }
  162|  11.7k|         (void)m( result );
  163|  11.7k|         return result;
  164|  11.7k|      }
  165|  11.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14rule_attributeINS4_9str_labelENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  11.7k|      {
   73|  11.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_controlIN8usbguard10RuleParser14rule_attributeINS4_9str_labelENS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  11.7k|      {
   44|  11.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  11.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_labelELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  11.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  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): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  11.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  11.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  11.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  11.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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: 4.24k, False: 7.49k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.24k|            else if constexpr( has_apply0_bool ) {
  153|  4.24k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.24k|            }
  155|  4.24k|         }
  156|  11.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.24k, False: 7.49k]
  ------------------
  157|  4.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.24k|         }
  159|  7.49k|         else {
  160|  7.49k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.49k|         }
  162|  11.7k|         (void)m( result );
  163|  11.7k|         return result;
  164|  11.7k|      }
  165|  11.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9str_labelELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_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|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   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_labelELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_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|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  10.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.3k|      else {
  108|  10.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.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|  10.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.40k, False: 1.97k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.40k|            else if constexpr( has_apply0_bool ) {
  153|  8.40k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.40k|            }
  155|  8.40k|         }
  156|  10.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.40k, False: 1.97k]
  ------------------
  157|  8.40k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.40k|         }
  159|  1.97k|         else {
  160|  1.97k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.97k|         }
  162|  10.3k|         (void)m( result );
  163|  10.3k|         return result;
  164|  10.3k|      }
  165|  10.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  10.3k|      {
   73|  10.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.3k|         else {
   84|  10.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  10.3k|      {
   44|  10.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  10.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.3k|      else {
  108|  10.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.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|  10.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.40k, False: 1.97k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  8.40k|            else if constexpr( has_apply0_bool ) {
  153|  8.40k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.40k|            }
  155|  8.40k|         }
  156|  10.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.40k, False: 1.97k]
  ------------------
  157|  8.40k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.40k|         }
  159|  1.97k|         else {
  160|  1.97k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.97k|         }
  162|  10.3k|         (void)m( result );
  163|  10.3k|         return result;
  164|  10.3k|      }
  165|  10.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  10.3k|      {
   73|  10.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.3k|         else {
   84|  10.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  10.3k|      {
   59|  10.3k|         return Rule::match( in );
   60|  10.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  16.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.7k|      else {
  108|  16.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  16.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  16.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  16.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  16.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  16.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  16.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  16.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.47k, False: 13.2k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.47k|            else if constexpr( has_apply0_bool ) {
  153|  3.47k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.47k|            }
  155|  3.47k|         }
  156|  16.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.47k, False: 13.2k]
  ------------------
  157|  3.47k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.47k|         }
  159|  13.2k|         else {
  160|  13.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.2k|         }
  162|  16.7k|         (void)m( result );
  163|  16.7k|         return result;
  164|  16.7k|      }
  165|  16.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  16.7k|      {
   73|  16.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  16.7k|         else {
   84|  16.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  16.7k|      {
   59|  16.7k|         return Rule::match( in );
   60|  16.7k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.22k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.22k|      else {
  108|  4.22k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.22k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.22k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.22k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.22k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.22k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.22k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.22k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.22k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.22k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.22k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.22k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.22k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.22k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.22k|         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.22k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.22k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.22k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.22k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.22k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.53k, False: 688]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  3.53k|            else if constexpr( has_apply0_bool ) {
  153|  3.53k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.53k|            }
  155|  3.53k|         }
  156|  4.22k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.53k, False: 688]
  ------------------
  157|  3.53k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.53k|         }
  159|    688|         else {
  160|    688|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    688|         }
  162|  4.22k|         (void)m( result );
  163|  4.22k|         return result;
  164|  4.22k|      }
  165|  4.22k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.22k|      {
   73|  4.22k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.22k|         else {
   84|  4.22k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.22k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.22k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS5_12string_valueEEES7_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.22k|      {
   44|  4.22k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.22k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.22k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.22k|      else {
  108|  4.22k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.22k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.22k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.22k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.22k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.22k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.22k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.22k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.22k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.22k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.22k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.22k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.22k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.22k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.22k|         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.22k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.22k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.22k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.22k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.22k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.25k, False: 1.96k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  4.22k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.25k, False: 1.96k]
  ------------------
  157|  2.25k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.25k|         }
  159|  1.96k|         else {
  160|  1.96k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.96k|         }
  162|  4.22k|         (void)m( result );
  163|  4.22k|         return result;
  164|  4.22k|      }
  165|  4.22k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.22k|      {
   73|  4.22k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.22k|         else {
   84|  4.22k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.22k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.22k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.22k|      {
   44|  4.22k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.22k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.22k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.22k|      else {
  108|  4.22k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.22k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.22k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.22k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.22k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.22k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.22k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.22k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.22k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.22k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.22k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.22k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.22k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.22k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.22k|         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.22k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.22k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.22k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.22k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.22k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.22k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  4.22k|            else if constexpr( has_apply0_bool ) {
  153|  4.22k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.22k|            }
  155|  4.22k|         }
  156|  4.22k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.22k, False: 0]
  ------------------
  157|  4.22k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.22k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.22k|         (void)m( result );
  163|  4.22k|         return result;
  164|  4.22k|      }
  165|  4.22k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  4.22k|      {
   73|  4.22k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.22k|         else {
   84|  4.22k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.22k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.22k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.22k|      {
   44|  4.22k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.22k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
  103|  4.22k|   {
  104|  4.22k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.22k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.22k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.22k|      {
   44|  4.22k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.22k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.22k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.22k|      else {
  108|  4.22k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.22k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.22k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  4.22k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.22k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.22k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.22k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.22k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.22k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.22k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.22k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.22k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.22k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.22k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.22k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.22k|         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.22k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.22k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.22k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.22k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.22k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.22k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.62k, False: 2.59k]
  ------------------
  143|  1.62k|            if constexpr( has_apply_void ) {
  144|  1.62k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  1.62k|         }
  156|  4.22k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.62k, False: 2.59k]
  ------------------
  157|  1.62k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.62k|         }
  159|  2.59k|         else {
  160|  2.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.59k|         }
  162|  4.22k|         (void)m( result );
  163|  4.22k|         return result;
  164|  4.22k|      }
  165|  4.22k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.22k|      {
   73|  4.22k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.22k|         else {
   84|  4.22k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.22k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.22k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.22k|      {
   44|  4.22k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.22k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.22k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.22k|      else {
  108|  4.22k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.22k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.22k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.22k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.22k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.22k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.22k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.22k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.22k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.22k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.22k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.22k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.22k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.22k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.22k|         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.22k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.22k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.22k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.22k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.22k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 273, False: 3.94k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    273|            else if constexpr( has_apply0_bool ) {
  153|    273|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    273|            }
  155|    273|         }
  156|  4.22k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 273, False: 3.94k]
  ------------------
  157|    273|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    273|         }
  159|  3.94k|         else {
  160|  3.94k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.94k|         }
  162|  4.22k|         (void)m( result );
  163|  4.22k|         return result;
  164|  4.22k|      }
  165|  4.22k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  4.22k|      {
   73|  4.22k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.22k|         else {
   84|  4.22k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.22k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.22k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.22k|      {
   59|  4.22k|         return Rule::match( in );
   60|  4.22k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.94k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.94k|      else {
  108|  3.94k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.94k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.94k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.94k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.94k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.94k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.94k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.94k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.94k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.94k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.94k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.94k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.94k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.94k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.94k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.94k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.94k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.94k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.94k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 252, False: 3.69k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    252|            else if constexpr( has_apply0_bool ) {
  153|    252|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    252|            }
  155|    252|         }
  156|  3.94k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 252, False: 3.69k]
  ------------------
  157|    252|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    252|         }
  159|  3.69k|         else {
  160|  3.69k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.69k|         }
  162|  3.94k|         (void)m( result );
  163|  3.94k|         return result;
  164|  3.94k|      }
  165|  3.94k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.94k|      {
   73|  3.94k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.94k|         else {
   84|  3.94k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.94k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.94k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.94k|      {
   59|  3.94k|         return Rule::match( in );
   60|  3.94k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.69k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.69k|      else {
  108|  3.69k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.69k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.69k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.69k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.69k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.69k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.69k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.69k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.69k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.69k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.69k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.69k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.69k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.69k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.69k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.69k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.69k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.69k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.69k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 224, False: 3.47k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    224|            else if constexpr( has_apply0_bool ) {
  153|    224|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    224|            }
  155|    224|         }
  156|  3.69k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 224, False: 3.47k]
  ------------------
  157|    224|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    224|         }
  159|  3.47k|         else {
  160|  3.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.47k|         }
  162|  3.69k|         (void)m( result );
  163|  3.69k|         return result;
  164|  3.69k|      }
  165|  3.69k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.69k|      {
   73|  3.69k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.69k|         else {
   84|  3.69k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.69k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.69k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.69k|      {
   59|  3.69k|         return Rule::match( in );
   60|  3.69k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.47k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.47k|      else {
  108|  3.47k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.47k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.47k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.47k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.47k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.47k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.47k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.47k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  3.47k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.47k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.47k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.47k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  3.47k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.47k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.47k|         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.47k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.47k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.47k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.47k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.47k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 198, False: 3.27k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    198|            else if constexpr( has_apply0_bool ) {
  153|    198|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    198|            }
  155|    198|         }
  156|  3.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 198, False: 3.27k]
  ------------------
  157|    198|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    198|         }
  159|  3.27k|         else {
  160|  3.27k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.27k|         }
  162|  3.47k|         (void)m( result );
  163|  3.47k|         return result;
  164|  3.47k|      }
  165|  3.47k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.47k|      {
   73|  3.47k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.47k|         else {
   84|  3.47k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.47k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.47k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.47k|      {
   59|  3.47k|         return Rule::match( in );
   60|  3.47k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.27k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.27k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.27k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.27k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  3.27k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  3.27k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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 ) {
  ------------------
  |  Branch (142:14): [True: 427, False: 2.84k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    427|            else if constexpr( has_apply0_bool ) {
  153|    427|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    427|            }
  155|    427|         }
  156|  3.27k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 427, False: 2.84k]
  ------------------
  157|    427|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    427|         }
  159|  2.84k|         else {
  160|  2.84k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.84k|         }
  162|  3.27k|         (void)m( result );
  163|  3.27k|         return result;
  164|  3.27k|      }
  165|  3.27k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.27k|      {
   73|  3.27k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  3.27k|         else {
   84|  3.27k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.27k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.27k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.27k|      {
   59|  3.27k|         return Rule::match( in );
   60|  3.27k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.84k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.84k|      else {
  108|  2.84k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.84k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.84k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.84k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.84k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.84k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.84k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.84k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.84k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.84k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.84k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.84k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.84k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.84k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.84k|         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.84k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.84k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.84k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.84k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.84k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 250, False: 2.59k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    250|            else if constexpr( has_apply0_bool ) {
  153|    250|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    250|            }
  155|    250|         }
  156|  2.84k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 250, False: 2.59k]
  ------------------
  157|    250|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    250|         }
  159|  2.59k|         else {
  160|  2.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.59k|         }
  162|  2.84k|         (void)m( result );
  163|  2.84k|         return result;
  164|  2.84k|      }
  165|  2.84k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.84k|      {
   73|  2.84k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.84k|         else {
   84|  2.84k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.84k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.84k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.84k|      {
   59|  2.84k|         return Rule::match( in );
   60|  2.84k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.22k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.22k|      else {
  108|  4.22k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.22k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.22k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.22k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.22k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.22k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.22k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.22k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.22k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.22k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.22k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.22k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.22k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.22k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.22k|         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.22k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.22k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.22k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.22k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.22k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.46k, False: 1.75k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.46k|            else if constexpr( has_apply0_bool ) {
  153|  2.46k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.46k|            }
  155|  2.46k|         }
  156|  4.22k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.46k, False: 1.75k]
  ------------------
  157|  2.46k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.46k|         }
  159|  1.75k|         else {
  160|  1.75k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.75k|         }
  162|  4.22k|         (void)m( result );
  163|  4.22k|         return result;
  164|  4.22k|      }
  165|  4.22k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  4.22k|      {
   73|  4.22k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.22k|         else {
   84|  4.22k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.22k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.22k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  4.22k|      {
   59|  4.22k|         return Rule::match( in );
   60|  4.22k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.85k|      else {
  108|  4.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.85k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  4.85k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  4.85k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.85k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  4.85k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  4.85k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  4.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.85k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  4.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.85k|         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.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.85k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  4.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.85k, False: 0]
  ------------------
  157|  4.85k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.85k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.85k|         (void)m( result );
  163|  4.85k|         return result;
  164|  4.85k|      }
  165|  4.85k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  4.85k|      {
   73|  4.85k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  4.85k|         else {
   84|  4.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.85k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.85k|      {
   44|  4.85k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.85k|      }
_ZN3tao5pegtl5matchINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  2.46k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.46k|      else {
  108|  2.46k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.46k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.46k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.46k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.46k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.46k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.46k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.46k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.46k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.46k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.46k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.46k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.46k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.46k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.46k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.46k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.46k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.46k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.46k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.38k, False: 82]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  2.38k|            else if constexpr( has_apply0_bool ) {
  153|  2.38k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.38k|            }
  155|  2.38k|         }
  156|  2.46k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.38k, False: 82]
  ------------------
  157|  2.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.38k|         }
  159|     82|         else {
  160|     82|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     82|         }
  162|  2.46k|         (void)m( result );
  163|  2.46k|         return result;
  164|  2.46k|      }
  165|  2.46k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  2.46k|      {
   73|  2.46k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.46k|         else {
   84|  2.46k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.46k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.46k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.46k|      {
   44|  2.46k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.46k|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  2.40k|   {
  104|  2.40k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.40k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  2.40k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  2.40k|      {
   44|  2.40k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.40k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.51k|   {
  104|  4.51k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.51k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  4.51k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  4.51k|      {
   44|  4.51k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.51k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.38k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.38k|      else {
  108|  2.38k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.38k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.38k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.38k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.38k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.38k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  2.38k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  2.38k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  2.38k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.38k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.38k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.38k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  2.38k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.38k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.38k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.38k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.38k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.38k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.38k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.25k, False: 127]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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.38k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.25k, False: 127]
  ------------------
  157|  2.25k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.25k|         }
  159|    127|         else {
  160|    127|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    127|         }
  162|  2.38k|         (void)m( result );
  163|  2.38k|         return result;
  164|  2.38k|      }
  165|  2.38k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.38k|      {
   73|  2.38k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  2.38k|         else {
   84|  2.38k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.38k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.38k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.38k|      {
   59|  2.38k|         return Rule::match( in );
   60|  2.38k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.00k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.00k|      else {
  108|  7.00k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.00k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.00k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  7.00k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.00k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 7.00k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.00k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.00k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.00k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  7.00k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.00k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.00k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.00k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  7.00k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.00k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.00k|         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.00k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 7.00k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.00k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.00k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.00k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.00k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.83k, False: 1.17k]
  ------------------
  143|  5.83k|            if constexpr( has_apply_void ) {
  144|  5.83k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|  5.83k|         }
  156|  7.00k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.78k, False: 1.21k]
  ------------------
  157|  5.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.78k|         }
  159|  1.21k|         else {
  160|  1.21k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.21k|         }
  162|  7.00k|         (void)m( result );
  163|  7.00k|         return result;
  164|  7.00k|      }
  165|  7.00k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  7.00k|      {
   73|  7.00k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  7.00k|         else {
   84|  7.00k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.00k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.00k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  7.00k|      {
   44|  7.00k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.00k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.00k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.00k|      else {
  108|  7.00k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.00k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.00k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  7.00k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  7.00k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.00k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  7.00k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  7.00k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  7.00k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.00k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.00k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.00k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  7.00k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.00k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.00k|         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.00k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.00k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.00k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.00k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.00k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.14k, False: 865]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  6.14k|            else if constexpr( has_apply0_bool ) {
  153|  6.14k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.14k|            }
  155|  6.14k|         }
  156|  7.00k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.14k, False: 865]
  ------------------
  157|  6.14k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.14k|         }
  159|    865|         else {
  160|    865|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    865|         }
  162|  7.00k|         (void)m( result );
  163|  7.00k|         return result;
  164|  7.00k|      }
  165|  7.00k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.00k|      {
   73|  7.00k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  7.00k|         else {
   84|  7.00k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.00k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.00k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  7.00k|      {
   59|  7.00k|         return Rule::match( in );
   60|  7.00k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.14k|   {
  104|  6.14k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.14k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  6.14k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.14k|      {
   44|  6.14k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.14k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  6.14k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.14k|      else {
  108|  6.14k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.14k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.14k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  6.14k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  6.14k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.14k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  6.14k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  6.14k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  6.14k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.14k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.14k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.14k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  6.14k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.14k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.14k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.14k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.14k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.14k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.14k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.83k, False: 305]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.83k|            else if constexpr( has_apply0_bool ) {
  153|  5.83k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.83k|            }
  155|  5.83k|         }
  156|  6.14k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.83k, False: 305]
  ------------------
  157|  5.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.83k|         }
  159|    305|         else {
  160|    305|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    305|         }
  162|  6.14k|         (void)m( result );
  163|  6.14k|         return result;
  164|  6.14k|      }
  165|  6.14k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  6.14k|      {
   73|  6.14k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  6.14k|         else {
   84|  6.14k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.14k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.14k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  6.14k|      {
   44|  6.14k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.14k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  10.6M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.6M|      else {
  108|  10.6M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.6M|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.6M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.6M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.6M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.6M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.6M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.6M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.6M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.6M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.6M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.6M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.6M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.6M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.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|  10.6M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.6M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.6M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.6M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.6M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.83k, False: 10.6M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  5.83k|            else if constexpr( has_apply0_bool ) {
  153|  5.83k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.83k|            }
  155|  5.83k|         }
  156|  10.6M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.83k, False: 10.6M]
  ------------------
  157|  5.83k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.83k|         }
  159|  10.6M|         else {
  160|  10.6M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.6M|         }
  162|  10.6M|         (void)m( result );
  163|  10.6M|         return result;
  164|  10.6M|      }
  165|  10.6M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  10.6M|      {
   73|  10.6M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.6M|         else {
   84|  10.6M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.6M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.6M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  10.6M|      {
   59|  10.6M|         return Rule::match( in );
   60|  10.6M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  10.6M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.6M|      else {
  108|  10.6M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.6M|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.6M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.6M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.6M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.6M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.6M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.6M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.6M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.6M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.6M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.6M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.6M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.6M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.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|  10.6M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.6M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.6M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.6M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.6M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.6M, False: 305]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  10.6M|            else if constexpr( has_apply0_bool ) {
  153|  10.6M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.6M|            }
  155|  10.6M|         }
  156|  10.6M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.6M, False: 305]
  ------------------
  157|  10.6M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.6M|         }
  159|    305|         else {
  160|    305|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    305|         }
  162|  10.6M|         (void)m( result );
  163|  10.6M|         return result;
  164|  10.6M|      }
  165|  10.6M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  10.6M|      {
   73|  10.6M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.6M|         else {
   84|  10.6M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.6M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.6M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  10.6M|      {
   44|  10.6M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.6M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  10.6M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.6M|      else {
  108|  10.6M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.6M|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.6M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.6M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.6M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.6M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.6M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.6M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.6M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.6M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.6M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.6M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.6M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.6M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.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|  10.6M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.6M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.6M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.6M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.6M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 110k, False: 10.4M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  10.6M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 110k, False: 10.4M]
  ------------------
  157|   110k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   110k|         }
  159|  10.4M|         else {
  160|  10.4M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.4M|         }
  162|  10.6M|         (void)m( result );
  163|  10.6M|         return result;
  164|  10.6M|      }
  165|  10.6M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  10.6M|      {
   73|  10.6M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.6M|         else {
   84|  10.6M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.6M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.6M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  10.6M|      {
   44|  10.6M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.6M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  10.6M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.6M|      else {
  108|  10.6M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.6M|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.6M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.6M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.6M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.6M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.6M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.6M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.6M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.6M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.6M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.6M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.6M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.6M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.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|  10.6M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.6M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.6M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.6M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.6M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 110k, False: 10.4M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  10.6M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 110k, False: 10.4M]
  ------------------
  157|   110k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   110k|         }
  159|  10.4M|         else {
  160|  10.4M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.4M|         }
  162|  10.6M|         (void)m( result );
  163|  10.6M|         return result;
  164|  10.6M|      }
  165|  10.6M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  10.6M|      {
   73|  10.6M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.6M|         else {
   84|  10.6M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.6M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.6M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  10.6M|      {
   59|  10.6M|         return Rule::match( in );
   60|  10.6M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|   110k|   {
  104|   110k|      if constexpr( !Control< Rule >::enable ) {
  105|   110k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|   110k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   110k|      {
   44|   110k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   110k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   110k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   110k|      else {
  108|   110k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   110k|         using iterator_t = typename ParseInput::iterator_t;
  111|   110k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   110k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   110k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   110k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   110k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   110k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   110k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   110k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   110k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   110k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   110k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   110k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   110k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   110k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   110k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   110k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   110k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   110k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 110k, False: 105]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|   110k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 110k, False: 105]
  ------------------
  157|   110k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   110k|         }
  159|    105|         else {
  160|    105|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    105|         }
  162|   110k|         (void)m( result );
  163|   110k|         return result;
  164|   110k|      }
  165|   110k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|   110k|      {
   73|   110k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   110k|         else {
   84|   110k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   110k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   110k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS5_15escaped_decbyteENS5_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS5_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   110k|      {
   44|   110k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   110k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   110k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   110k|      else {
  108|   110k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   110k|         using iterator_t = typename ParseInput::iterator_t;
  111|   110k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   110k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   110k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   110k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   110k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   110k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   110k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   110k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   110k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   110k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   110k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   110k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   110k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   110k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   110k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   110k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   110k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   110k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.1k, False: 68.1k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  42.1k|            else if constexpr( has_apply0_bool ) {
  153|  42.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.1k|            }
  155|  42.1k|         }
  156|   110k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.1k, False: 68.1k]
  ------------------
  157|  42.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.1k|         }
  159|  68.1k|         else {
  160|  68.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  68.1k|         }
  162|   110k|         (void)m( result );
  163|   110k|         return result;
  164|   110k|      }
  165|   110k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   110k|      {
   73|   110k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   110k|         else {
   84|   110k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   110k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   110k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|   110k|      {
   44|   110k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   110k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   110k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   110k|      else {
  108|   110k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   110k|         using iterator_t = typename ParseInput::iterator_t;
  111|   110k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   110k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   110k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   110k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   110k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   110k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   110k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   110k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   110k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   110k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   110k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   110k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   110k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   110k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   110k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   110k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   110k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   110k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.1k, False: 68.1k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  42.1k|            else if constexpr( has_apply0_bool ) {
  153|  42.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.1k|            }
  155|  42.1k|         }
  156|   110k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.1k, False: 68.1k]
  ------------------
  157|  42.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.1k|         }
  159|  68.1k|         else {
  160|  68.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  68.1k|         }
  162|   110k|         (void)m( result );
  163|   110k|         return result;
  164|   110k|      }
  165|   110k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   110k|      {
   73|   110k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   110k|         else {
   84|   110k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   110k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   110k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   110k|      {
   59|   110k|         return Rule::match( in );
   60|   110k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  42.1k|   {
  104|  42.1k|      if constexpr( !Control< Rule >::enable ) {
  105|  42.1k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  42.1k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  42.1k|      {
   44|  42.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.1k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  42.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.1k|      else {
  108|  42.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  42.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  42.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  42.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  42.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  42.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  42.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  42.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.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|  42.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.1k, False: 45]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  42.1k|            else if constexpr( has_apply0_bool ) {
  153|  42.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.1k|            }
  155|  42.1k|         }
  156|  42.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.1k, False: 45]
  ------------------
  157|  42.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.1k|         }
  159|     45|         else {
  160|     45|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     45|         }
  162|  42.1k|         (void)m( result );
  163|  42.1k|         return result;
  164|  42.1k|      }
  165|  42.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  42.1k|      {
   73|  42.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  42.1k|         else {
   84|  42.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  42.1k|      {
   44|  42.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.1k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  84.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  84.3k|      else {
  108|  84.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  84.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  84.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  84.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  84.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  84.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  84.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  84.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  84.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  84.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  84.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  84.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  84.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  84.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  84.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|  84.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  84.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  84.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  84.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  84.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 84.3k, False: 45]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  84.3k|            else if constexpr( has_apply0_bool ) {
  153|  84.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  84.3k|            }
  155|  84.3k|         }
  156|  84.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 84.3k, False: 45]
  ------------------
  157|  84.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  84.3k|         }
  159|     45|         else {
  160|     45|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     45|         }
  162|  84.3k|         (void)m( result );
  163|  84.3k|         return result;
  164|  84.3k|      }
  165|  84.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  84.3k|      {
   73|  84.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  84.3k|         else {
   84|  84.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  84.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  84.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  84.3k|      {
   59|  84.3k|         return Rule::match( in );
   60|  84.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  68.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  68.1k|      else {
  108|  68.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  68.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  68.1k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  68.1k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  68.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  68.1k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  68.1k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  68.1k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  68.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  68.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  68.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  68.1k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  68.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  68.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  68.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|  68.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  68.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  68.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  68.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  68.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.3k, False: 32.7k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  35.3k|            else if constexpr( has_apply0_bool ) {
  153|  35.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.3k|            }
  155|  35.3k|         }
  156|  68.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.3k, False: 32.7k]
  ------------------
  157|  35.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.3k|         }
  159|  32.7k|         else {
  160|  32.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  32.7k|         }
  162|  68.1k|         (void)m( result );
  163|  68.1k|         return result;
  164|  68.1k|      }
  165|  68.1k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  68.1k|      {
   73|  68.1k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  68.1k|         else {
   84|  68.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  68.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  68.1k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  68.1k|      {
   44|  68.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  68.1k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   109k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  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... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   109k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   109k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   109k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   109k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   109k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  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|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  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;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  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 ) {
  ------------------
  |  Branch (142:14): [True: 44.6k, False: 64.6k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  44.6k|            else if constexpr( has_apply0_bool ) {
  153|  44.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  44.6k|            }
  155|  44.6k|         }
  156|   109k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 44.6k, False: 64.6k]
  ------------------
  157|  44.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  44.6k|         }
  159|  64.6k|         else {
  160|  64.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  64.6k|         }
  162|   109k|         (void)m( result );
  163|   109k|         return result;
  164|   109k|      }
  165|   109k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   109k|      {
   73|   109k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   109k|         else {
   84|   109k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   109k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   109k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   109k|      {
   59|   109k|         return Rule::match( in );
   60|   109k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  35.3k|   {
  104|  35.3k|      if constexpr( !Control< Rule >::enable ) {
  105|  35.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  35.3k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  35.3k|      {
   44|  35.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  35.3k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  35.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  35.3k|      else {
  108|  35.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  35.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  35.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  35.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  35.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  35.3k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  35.3k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  35.3k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  35.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  35.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  35.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  35.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  35.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  35.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  35.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|  35.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  35.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  35.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  35.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  35.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.3k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  35.3k|            else if constexpr( has_apply0_bool ) {
  153|  35.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.3k|            }
  155|  35.3k|         }
  156|  35.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.3k, False: 0]
  ------------------
  157|  35.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.3k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  35.3k|         (void)m( result );
  163|  35.3k|         return result;
  164|  35.3k|      }
  165|  35.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
   72|  35.3k|      {
   73|  35.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  35.3k|         else {
   84|  35.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  35.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  35.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  35.3k|      {
   44|  35.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  35.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  32.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  32.7k|      else {
  108|  32.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  32.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  32.7k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  32.7k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  32.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  32.7k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  32.7k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  32.7k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  32.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  32.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  32.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  32.7k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  32.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  32.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  32.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|  32.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  32.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  32.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  32.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  32.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 31.0k, False: 1.69k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  31.0k|            else if constexpr( has_apply0_bool ) {
  153|  31.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  31.0k|            }
  155|  31.0k|         }
  156|  32.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 31.0k, False: 1.69k]
  ------------------
  157|  31.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  31.0k|         }
  159|  1.69k|         else {
  160|  1.69k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.69k|         }
  162|  32.7k|         (void)m( result );
  163|  32.7k|         return result;
  164|  32.7k|      }
  165|  32.7k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  32.7k|      {
   73|  32.7k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  32.7k|         else {
   84|  32.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  32.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  32.7k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  32.7k|      {
   59|  32.7k|         return Rule::match( in );
   60|  32.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.69k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.69k|      else {
  108|  1.69k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.69k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.69k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.69k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.69k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  1.69k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.69k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.69k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  1.69k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.69k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.69k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.69k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  1.69k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.69k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.69k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.69k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.69k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.69k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.69k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.63k, False: 60]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  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|  1.69k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.63k, False: 60]
  ------------------
  157|  1.63k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.63k|         }
  159|     60|         else {
  160|     60|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     60|         }
  162|  1.69k|         (void)m( result );
  163|  1.69k|         return result;
  164|  1.69k|      }
  165|  1.69k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  1.69k|      {
   73|  1.69k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  1.69k|         else {
   84|  1.69k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.69k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.69k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  1.69k|      {
   59|  1.69k|         return Rule::match( in );
   60|  1.69k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  10.4M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.4M|      else {
  108|  10.4M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.4M|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.4M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  10.4M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  10.4M|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  10.4M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  10.4M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  10.4M|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  10.4M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.4M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.4M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.4M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  10.4M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.4M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.4M|         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.4M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.4M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.4M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.4M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.4M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.4M, False: 200]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  10.4M|            else if constexpr( has_apply0_bool ) {
  153|  10.4M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.4M|            }
  155|  10.4M|         }
  156|  10.4M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.4M, False: 200]
  ------------------
  157|  10.4M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.4M|         }
  159|    200|         else {
  160|    200|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    200|         }
  162|  10.4M|         (void)m( result );
  163|  10.4M|         return result;
  164|  10.4M|      }
  165|  10.4M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  10.4M|      {
   73|  10.4M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  10.4M|         else {
   84|  10.4M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.4M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.4M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  10.4M|      {
   59|  10.4M|         return Rule::match( in );
   60|  10.4M|      }
_ZN3tao5pegtl5matchINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15rule_attributesEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  26.2k|   {
  104|  26.2k|      if constexpr( !Control< Rule >::enable ) {
  105|  26.2k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  26.2k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15rule_attributesEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  26.2k|      {
   44|  26.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  26.2k|      }
_ZN3tao5pegtl5matchINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15rule_attributesEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  29.3k|   {
  104|  29.3k|      if constexpr( !Control< Rule >::enable ) {
  105|  29.3k|         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|       |      else {
  108|       |         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|       |         using iterator_t = typename ParseInput::iterator_t;
  111|       |         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  112|       |         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  113|       |         constexpr bool has_apply = has_apply_void || has_apply_bool;
  114|       |
  115|       |         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  116|       |         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  117|       |         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  118|       |
  119|       |         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|       |         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|       |         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|       |         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|       |         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|       |         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|       |         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|       |         constexpr bool use_marker = has_apply || has_apply0_bool;
  138|       |
  139|       |         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|       |         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|       |         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|       |         if( result ) {
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|       |            else if constexpr( has_apply0_bool ) {
  153|       |               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|       |            }
  155|       |         }
  156|       |         if( result ) {
  157|       |            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|       |         }
  159|       |         else {
  160|       |            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|       |         }
  162|       |         (void)m( result );
  163|       |         return result;
  164|       |      }
  165|  29.3k|   }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS1_3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15rule_attributesEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  29.3k|      {
   44|  29.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.3k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser7commentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  33.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  33.6k|      else {
  108|  33.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  33.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  33.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  33.6k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  33.6k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  33.6k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  33.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  33.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.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|  33.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  33.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.6k, False: 0]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  33.6k|            else if constexpr( has_apply0_bool ) {
  153|  33.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.6k|            }
  155|  33.6k|         }
  156|  33.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.6k, False: 0]
  ------------------
  157|  33.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.6k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  33.6k|         (void)m( result );
  163|  33.6k|         return result;
  164|  33.6k|      }
  165|  33.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3optIJN8usbguard10RuleParser7commentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDaRT4_DpOT5_:
   72|  33.6k|      {
   73|  33.6k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  33.6k|         else {
   84|  33.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.6k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3optIJN8usbguard10RuleParser7commentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  33.6k|      {
   44|  33.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.6k|      }
_ZN3tao5pegtl5matchINS0_4mustIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  33.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  33.8k|      else {
  108|  33.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  33.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  33.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  33.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  33.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  33.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  33.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  33.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.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|  33.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  33.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.2k, False: 4.55k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.2k|            else if constexpr( has_apply0_bool ) {
  153|  29.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.2k|            }
  155|  29.2k|         }
  156|  33.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.2k, False: 4.55k]
  ------------------
  157|  29.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.2k|         }
  159|  4.55k|         else {
  160|  4.55k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.55k|         }
  162|  33.8k|         (void)m( result );
  163|  33.8k|         return result;
  164|  33.8k|      }
  165|  33.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_4mustIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  33.8k|      {
   73|  33.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  33.8k|         else {
   84|  33.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_4mustIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchIXT0_EXT1_ET2_T3_Efp_spfp0_EERT4_DpOT5_:
   43|  33.8k|      {
   44|  33.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.8k|      }
_ZN3tao5pegtl5matchINS0_3eofELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  33.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  33.8k|      else {
  108|  33.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.8k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  33.8k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  33.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  33.8k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  33.8k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  33.8k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  33.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.8k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  33.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.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|  33.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  33.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 29.2k, False: 4.55k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  29.2k|            else if constexpr( has_apply0_bool ) {
  153|  29.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  29.2k|            }
  155|  29.2k|         }
  156|  33.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 29.2k, False: 4.55k]
  ------------------
  157|  29.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  29.2k|         }
  159|  4.55k|         else {
  160|  4.55k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.55k|         }
  162|  33.8k|         (void)m( result );
  163|  33.8k|         return result;
  164|  33.8k|      }
  165|  33.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_3eofELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
   72|  33.8k|      {
   73|  33.8k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|  33.8k|         else {
   84|  33.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.8k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_3eofELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS6_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  33.8k|      {
   59|  33.8k|         return Rule::match( in );
   60|  33.8k|      }

_ZN3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE4markILNS0_11rewind_modeE2EEENS0_8internal6markerINSG_8iteratorEXT_EEEv:
  338|   594M|      {
  339|   594M|         return internal::marker< iterator_t, M >( iterator() );
  340|   594M|      }
_ZN3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE8iteratorEv:
  308|   605M|      {
  309|   605M|         return this->m_current;
  310|   605M|      }
_ZN3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE4markILNS0_11rewind_modeE1EEENS0_8internal6markerINSG_8iteratorEXT_EEEv:
  338|  8.51M|      {
  339|  8.51M|         return internal::marker< iterator_t, M >( iterator() );
  340|  8.51M|      }
_ZNK3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE5emptyEv:
  288|   365M|      {
  289|   365M|         return this->current() == this->end();
  290|   365M|      }
_ZNK3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEE7currentEv:
   69|   732M|         {
   70|   732M|            return m_current.data;
   71|   732M|         }
_ZNK3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEE3endEm:
   79|   365M|         {
   80|   365M|            return m_end;
   81|   365M|         }
_ZNK3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE9peek_charEm:
  298|   363M|      {
  299|   363M|         return this->current()[ offset ];
  300|   363M|      }
_ZN3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEE17bump_in_this_lineEm:
  104|   145M|         {
  105|   145M|            internal::bump_in_this_line( m_current, in_count );
  106|   145M|         }
_ZN3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEE4bumpEm:
   99|   929k|         {
  100|   929k|            internal::bump( m_current, in_count, Eol::ch );
  101|   929k|         }
_ZNK3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE8positionEv:
  328|  6.81k|      {
  329|  6.81k|         return position( iterator() );
  330|  6.81k|      }
_ZNK3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEE8positionERKNS1_8iteratorE:
  114|  9.18k|         {
  115|  9.18k|            return TAO_PEGTL_NAMESPACE::position( it, m_source );
  ------------------
  |  |    8|  9.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
  116|  9.18k|         }
_ZNK3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE8iteratorEv:
  313|  6.81k|      {
  314|  6.81k|         return this->m_current;
  315|  6.81k|      }
_ZNK3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE4sizeEm:
  293|   506k|      {
  294|   506k|         return std::size_t( this->end() - this->current() );
  295|   506k|      }
_ZN3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE4markILNS0_11rewind_modeE0EEENS0_8internal6markerINSG_8iteratorEXT_EEEv:
  338|  2.68M|      {
  339|  2.68M|         return internal::marker< iterator_t, M >( iterator() );
  340|  2.68M|      }
_ZN3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEED2Ev:
   63|  38.4k|         ~memory_input_base() = default;
_ZN3tao5pegtl12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEC2IRKSC_EEPKcmOT_:
  248|  38.4k|         : memory_input( in_begin, in_begin + in_size, std::forward< T >( in_source ) )
  249|  38.4k|      {}
_ZN3tao5pegtl8internal17memory_input_baseILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEEC2IRKSD_EEPKcSJ_OT_:
   54|  38.4k|            : m_begin( in_begin ),
   55|  38.4k|              m_current( in_begin ),
   56|  38.4k|              m_end( in_end ),
   57|  38.4k|              m_source( std::forward< T >( in_source ) )
   58|  38.4k|         {}

_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.4k|         else {
   92|  38.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.4k|         }
   94|  38.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.4k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   144k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   144k|         else {
   92|   144k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   144k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   144k|         }
   94|   144k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   192k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   248k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   248k|         else {
   92|   248k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   248k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   248k|         }
   94|   248k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  6.20M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  3.75M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  2.44M|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   192k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS5_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  38.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.4k|         else {
   92|  38.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.4k|         }
   94|  38.4k|      }
_ZN3tao5pegtl6normalINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEvRKT_DpOT0_:
   36|  38.4k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  38.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.4k|         else {
   92|  38.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.4k|         }
   94|  38.4k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  38.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  72.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  72.1k|         else {
   92|  72.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  72.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  72.1k|         }
   94|  72.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  72.1k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNSJ_4RuleEEEEbRT3_DpOT4_:
   87|  72.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  72.1k|         else {
   92|  72.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  72.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  72.1k|         }
   94|  72.1k|      }
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  72.1k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  72.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  72.1k|         else {
   92|  72.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  72.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  72.1k|         }
   94|  72.1k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  72.1k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  10.3k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  61.7k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS9_3eol7lf_crlfENSt3__112basic_stringIcNSP_11char_traitsIcEENSP_9allocatorIcEEEEEEJRNSI_4RuleEEEEbRT3_DpOT4_:
   87|  10.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.3k|         else {
   92|  10.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.3k|         }
   94|  10.3k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNSF_4RuleEEEEbRT3_DpOT4_:
   87|  10.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.3k|         else {
   92|  10.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.3k|         }
   94|  10.3k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  10.3k|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|   523k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   523k|         else {
   92|   523k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   523k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   523k|         }
   94|   523k|      }
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   523k|      {}
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   523k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   523k|         else {
   92|   523k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   523k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   523k|         }
   94|   523k|      }
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   523k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE5matchILNS0_10apply_modeE0ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|   523k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   523k|         else {
   92|   523k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   523k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   523k|         }
   94|   523k|      }
_ZN3tao5pegtl6normalINS0_3eofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   557k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  39.5k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   517k|      {}
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   513k|      {}
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  10.3k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3anyEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   513k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   513k|         else {
   92|   513k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   513k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   513k|         }
   94|   513k|      }
_ZN3tao5pegtl6normalINS0_5ascii3anyEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   513k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3anyEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   513k|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   513k|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  10.3k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  10.3k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  10.3k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  61.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE6apply0ITtTpTyENS3_19rule_parser_actionsENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE6apply0spfp0_EERKT0_DpOT1_:
   74|  10.3k|      {
   75|  10.3k|         return Action< Rule >::apply0( st... );
   76|  10.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  10.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  61.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.4k|         else {
   92|  38.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.4k|         }
   94|  38.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.4k|         else {
   92|  38.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.4k|         }
   94|  38.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.4k|         else {
   92|  38.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.4k|         }
   94|  38.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  34.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  3.80k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.80k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.80k|         else {
   92|  3.80k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.80k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.80k|         }
   94|  3.80k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  3.80k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.71k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.09k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.09k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.09k|         else {
   92|  1.09k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.09k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.09k|         }
   94|  1.09k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.09k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|     14|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.07k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.07k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.07k|         else {
   92|  1.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.07k|         }
   94|  1.07k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.07k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|    925|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    152|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|    152|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    152|         else {
   92|    152|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    152|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    152|         }
   94|    152|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|    152|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|     48|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    104|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5applyITtTpTyENS3_19rule_parser_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  38.2k|      {
   65|  38.2k|         const typename ParseInput::action_t action_input( begin, in );
   66|  38.2k|         return Action< Rule >::apply( action_input, st... );
   67|  38.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  38.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    104|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|  38.2k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.2k|         else {
   92|  38.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.2k|         }
   94|  38.2k|      }
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS7_4RuleEEEEvRKT_DpOT0_:
   36|  38.2k|      {}
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  38.2k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.2k|         else {
   92|  38.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.2k|         }
   94|  38.2k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   105k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   105k|         else {
   92|   105k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   105k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   105k|         }
   94|   105k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  2.25M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   105k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   105k|         else {
   92|   105k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   105k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   105k|         }
   94|   105k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  2.21M|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  42.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.2k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.2k|         else {
   92|  38.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.2k|         }
   94|  38.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.2k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.2k|         else {
   92|  38.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.2k|         }
   94|  38.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   995k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  40.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  40.0k|         else {
   92|  40.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.0k|         }
   94|  40.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.95M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  45.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  45.8k|         else {
   92|  45.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.8k|         }
   94|  45.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  3.52M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.41M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  2.10M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.26k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.94M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  38.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.1k|         else {
   92|  38.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.1k|         }
   94|  38.1k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  2.10M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  2.06M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  38.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   956k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  38.4k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.78k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.28M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.28M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|    141|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.76k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.76k|         else {
   92|  1.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.76k|         }
   94|  1.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   956k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   956k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|     32|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE5applyITtTpTyENS3_19rule_parser_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.75k|      {
   65|  1.75k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.75k|         return Action< Rule >::apply( action_input, st... );
   67|  1.75k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  1.75k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  36.5k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS7_4RuleEEEEvRKT_DpOT0_:
   40|  38.2k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  38.2k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.2k|         else {
   92|  38.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.2k|         }
   94|  38.2k|      }
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS8_4RuleEEEEvRKT_DpOT0_:
   36|  38.2k|      {}
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES7_vEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENSA_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  38.2k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.2k|         else {
   92|  38.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.2k|         }
   94|  38.2k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  37.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  37.0k|         else {
   92|  37.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.0k|         }
   94|  37.0k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  37.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  41.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  41.8k|         else {
   92|  41.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.8k|         }
   94|  41.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  41.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  41.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  41.8k|         else {
   92|  41.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.8k|         }
   94|  41.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  41.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  41.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  41.8k|         else {
   92|  41.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.8k|         }
   94|  41.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  41.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  41.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  41.8k|         else {
   92|  41.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  41.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  41.8k|         }
   94|  41.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  41.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5applyITtTpTyENS3_10id_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  3.88k|      {
   65|  3.88k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.88k|         return Action< Rule >::apply( action_input, st... );
   67|  3.88k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.87k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.9k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   959k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   959k|         else {
   92|   959k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   959k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   959k|         }
   94|   959k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   959k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   959k|         else {
   92|   959k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   959k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   959k|         }
   94|   959k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   974k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   974k|         else {
   92|   974k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   974k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   974k|         }
   94|   974k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.85k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.85k|         else {
   92|  3.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.85k|         }
   94|  3.85k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.85k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.85k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.85k|         else {
   92|  3.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.85k|         }
   94|  3.85k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  3.85k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.85k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.85k|         else {
   92|  3.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.85k|         }
   94|  3.85k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  37.7k|      {}
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.85k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.85k|         else {
   92|  3.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.85k|         }
   94|  3.85k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.85k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.85k|         else {
   92|  3.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.85k|         }
   94|  3.85k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.85k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.85k|         else {
   92|  3.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.85k|         }
   94|  3.85k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.05k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  35.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.63k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.63k|         else {
   92|  3.63k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.63k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.63k|         }
   94|  3.63k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  35.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.51k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  33.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.42k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.42k|         else {
   92|  3.42k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.42k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.42k|         }
   94|  3.42k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  33.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.29k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  30.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.20k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.20k|         else {
   92|  3.20k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.20k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.20k|         }
   94|  3.20k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  30.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.66k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  28.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.52k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_equalsEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  28.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.32k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.08k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.08k|         else {
   92|  2.08k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.08k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.08k|         }
   94|  2.08k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.45k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  22.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_10id_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.97k|      {
   65|  1.97k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.97k|         return Action< Rule >::apply( action_input, st... );
   67|  1.97k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  15.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  22.4k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  37.7k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.85k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.85k|         else {
   92|  3.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.85k|         }
   94|  3.85k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  37.7k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  24.9k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  12.8k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  5.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.10k|         else {
   92|  5.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.10k|         }
   94|  5.10k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.59k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.59k|         else {
   92|  2.59k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.59k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.59k|         }
   94|  2.59k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  2.59k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15device_id_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.51k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.51k|         else {
   92|  2.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.51k|         }
   94|  2.51k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15device_id_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   953k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   953k|         else {
   92|   953k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   953k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   953k|         }
   94|   953k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.51k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     74|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.51k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.51k|         else {
   92|  2.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.51k|         }
   94|  2.51k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  23.0k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  21.2k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.83k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.35k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.50k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   956k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   956k|         else {
   92|   956k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   956k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   956k|         }
   94|   956k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   956k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   956k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   956k|         else {
   92|   956k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   956k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   956k|         }
   94|   956k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.91M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.91M|         else {
   92|  1.91M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.91M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.91M|         }
   94|  1.91M|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.91M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.91M|         else {
   92|  1.91M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.91M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.91M|         }
   94|  1.91M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.90M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.90M|         else {
   92|  1.90M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.90M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.90M|         }
   94|  1.90M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   954k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   954k|         else {
   92|   954k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   954k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   954k|         }
   94|   954k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   954k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   954k|         else {
   92|   954k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   954k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   954k|         }
   94|   954k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5applyITtTpTyENS3_10id_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|   954k|      {
   65|   954k|         const typename ParseInput::action_t action_input( begin, in );
   66|   954k|         return Action< Rule >::apply( action_input, st... );
   67|   954k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   954k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.99k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  3.38k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    466|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.38k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  38.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.38k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  38.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.4k|         else {
   92|  38.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.4k|         }
   94|  38.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.4k|         else {
   92|  38.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.4k|         }
   94|  38.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  38.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  38.4k|         else {
   92|  38.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.4k|         }
   94|  38.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  38.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5applyITtTpTyENS3_12name_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  3.62k|      {
   65|  3.62k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.62k|         return Action< Rule >::apply( action_input, st... );
   67|  3.62k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.62k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  34.7k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   315k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   315k|         else {
   92|   315k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   315k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   315k|         }
   94|   315k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   315k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   315k|         else {
   92|   315k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   315k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   315k|         }
   94|   315k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   323k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.60k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.60k|         else {
   92|  3.60k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.60k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.60k|         }
   94|  3.60k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  24.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.60k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.60k|         else {
   92|  3.60k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.60k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.60k|         }
   94|  3.60k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.6k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.60k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.60k|         else {
   92|  3.60k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.60k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.60k|         }
   94|  3.60k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.60k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.60k|         else {
   92|  3.60k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.60k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.60k|         }
   94|  3.60k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.60k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.60k|         else {
   92|  3.60k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.60k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.60k|         }
   94|  3.60k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.60k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.60k|         else {
   92|  3.60k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.60k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.60k|         }
   94|  3.60k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.40k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.40k|         else {
   92|  3.40k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.40k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.40k|         }
   94|  3.40k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.98k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.98k|         else {
   92|  2.98k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.98k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.98k|         }
   94|  2.98k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.69k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.50k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.50k|         else {
   92|  2.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.50k|         }
   94|  2.50k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.27k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_12name_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.53k|      {
   65|  1.53k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.53k|         return Action< Rule >::apply( action_input, st... );
   67|  1.53k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.60k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.60k|         else {
   92|  3.60k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.60k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.60k|         }
   94|  3.60k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.86k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.86k|         else {
   92|  4.86k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.86k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.86k|         }
   94|  4.86k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.46k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.46k|         else {
   92|  2.46k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.46k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.46k|         }
   94|  2.46k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  16.1k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.41k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.41k|         else {
   92|  2.41k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.41k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.41k|         }
   94|  2.41k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   310k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   310k|         else {
   92|   310k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   310k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   310k|         }
   94|   310k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  15.6k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    282|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.39k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  14.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  9.61k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   312k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   312k|         else {
   92|   312k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   312k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   312k|         }
   94|   312k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   354k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   312k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   312k|         else {
   92|   312k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   312k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   312k|         }
   94|   312k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  61.7M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   704k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  61.0M|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   311k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   311k|         else {
   92|   311k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   311k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   311k|         }
   94|   311k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|   311k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   311k|         else {
   92|   311k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   311k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   311k|         }
   94|   311k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   36|   347k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  17.0M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  17.0M|         else {
   92|  17.0M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  17.0M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  17.0M|         }
   94|  17.0M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  16.7M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  16.7M|         else {
   92|  16.7M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.7M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.7M|         }
   94|  16.7M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  61.0M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  16.7M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  16.7M|         else {
   92|  16.7M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.7M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.7M|         }
   94|  16.7M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  61.0M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  16.7M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  16.7M|         else {
   92|  16.7M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.7M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.7M|         }
   94|  16.7M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   105M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.01M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   104M|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|   264k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   264k|         else {
   92|   264k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   264k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   264k|         }
   94|   264k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   264k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   264k|         else {
   92|   264k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   264k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   264k|         }
   94|   264k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   837k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   264k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   264k|         else {
   92|   264k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   264k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   264k|         }
   94|   264k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.01M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   264k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   264k|         else {
   92|   264k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   264k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   264k|         }
   94|   264k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.01M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   360k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   652k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|   117k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   117k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   360k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   235k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   235k|         else {
   92|   235k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   235k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   235k|         }
   94|   235k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   359k|      {}
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|    269|      {}
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   48|    269|      {
   49|    269|#if defined( __cpp_exceptions )
   50|    269|         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|    269|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   359k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   652k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   146k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   146k|         else {
   92|   146k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   146k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   146k|         }
   94|   146k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   652k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   191k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   191k|         else {
   92|   191k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   191k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   191k|         }
   94|   191k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   917k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   289k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   628k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  39.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  39.4k|         else {
   92|  39.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  39.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  39.4k|         }
   94|  39.4k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  39.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  39.4k|         else {
   92|  39.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  39.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  39.4k|         }
   94|  39.4k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   224k|      {}
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   224k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   224k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   428k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   106k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   106k|         else {
   92|   106k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   106k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   106k|         }
   94|   106k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   428k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   416k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  11.6k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.62k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.62k|         else {
   92|  4.62k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.62k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.62k|         }
   94|  4.62k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   837k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    349|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   48|    349|      {
   49|    349|#if defined( __cpp_exceptions )
   50|    349|         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|    349|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   837k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  60.1M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  16.4M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  16.4M|         else {
   92|  16.4M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.4M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.4M|         }
   94|  16.4M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   104M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   104M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.58k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  61.0M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.32k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   40|   346k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   44|  1.32k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   48|  1.32k|      {
   49|  1.32k|#if defined( __cpp_exceptions )
   50|  1.32k|         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.32k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_12name_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|   311k|      {
   65|   311k|         const typename ParseInput::action_t action_input( begin, in );
   66|   311k|         return Action< Rule >::apply( action_input, st... );
   67|   311k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   345k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  6.57k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  20.1k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|  2.20k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.90k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  35.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.90k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  35.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  35.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  35.1k|         else {
   92|  35.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.1k|         }
   94|  35.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  35.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  35.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  35.1k|         else {
   92|  35.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.1k|         }
   94|  35.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  35.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  35.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  35.1k|         else {
   92|  35.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.1k|         }
   94|  35.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  35.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5applyITtTpTyENS3_12hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  4.13k|      {
   65|  4.13k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.13k|         return Action< Rule >::apply( action_input, st... );
   67|  4.13k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.12k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  30.9k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  11.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  11.8k|         else {
   92|  11.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.8k|         }
   94|  11.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  11.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  11.8k|         else {
   92|  11.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.8k|         }
   94|  11.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  20.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  20.7k|         else {
   92|  20.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  20.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  20.7k|         }
   94|  20.7k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.89k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.89k|         else {
   92|  3.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.89k|         }
   94|  3.89k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.61k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.61k|         else {
   92|  3.61k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.61k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.61k|         }
   94|  3.61k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.40k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.40k|         else {
   92|  3.40k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.40k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.40k|         }
   94|  3.40k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.21k|         else {
   92|  3.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.21k|         }
   94|  3.21k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.88k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.88k|         else {
   92|  2.88k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.88k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.88k|         }
   94|  2.88k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_12hash_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_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.10k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.10k|         else {
   92|  4.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.10k|         }
   94|  4.10k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  5.39k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.39k|         else {
   92|  5.39k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.39k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.39k|         }
   94|  5.39k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.74k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_modeE0ETtTpTyENS9_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.67k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  6.27k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.27k|         else {
   92|  6.27k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.27k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.27k|         }
   94|  6.27k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.65k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.74k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.74k|         else {
   92|  8.74k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.74k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.74k|         }
   94|  8.74k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.74k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.74k|         else {
   92|  8.74k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.74k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.74k|         }
   94|  8.74k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  7.50k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.50k|         else {
   92|  7.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.50k|         }
   94|  7.50k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  7.50k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.50k|         else {
   92|  7.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.50k|         }
   94|  7.50k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.87M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.87M|         else {
   92|  9.87M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.87M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.87M|         }
   94|  9.87M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.86M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.86M|         else {
   92|  9.86M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.86M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.86M|         }
   94|  9.86M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.86M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.86M|         else {
   92|  9.86M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.86M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.86M|         }
   94|  9.86M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.86M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.86M|         else {
   92|  9.86M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.86M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.86M|         }
   94|  9.86M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|   143k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   143k|         else {
   92|   143k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   143k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   143k|         }
   94|   143k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   143k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   143k|         else {
   92|   143k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   143k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   143k|         }
   94|   143k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   143k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   143k|         else {
   92|   143k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   143k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   143k|         }
   94|   143k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   143k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   143k|         else {
   92|   143k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   143k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   143k|         }
   94|   143k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  48.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  48.1k|         else {
   92|  48.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.1k|         }
   94|  48.1k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  48.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  48.1k|         else {
   92|  48.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.1k|         }
   94|  48.1k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  96.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  96.1k|         else {
   92|  96.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  96.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  96.1k|         }
   94|  96.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  95.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  95.4k|         else {
   92|  95.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  95.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  95.4k|         }
   94|  95.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   148k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   148k|         else {
   92|   148k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   148k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   148k|         }
   94|   148k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  48.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  48.0k|         else {
   92|  48.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.0k|         }
   94|  48.0k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  48.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  48.0k|         else {
   92|  48.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.0k|         }
   94|  48.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  47.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  47.4k|         else {
   92|  47.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  47.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  47.4k|         }
   94|  47.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    897|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    897|         else {
   92|    897|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    897|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    897|         }
   94|    897|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.71M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_12hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  7.19k|      {
   65|  7.19k|         const typename ParseInput::action_t action_input( begin, in );
   66|  7.19k|         return Action< Rule >::apply( action_input, st... );
   67|  7.19k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.38k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  31.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.38k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  31.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  31.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  31.3k|         else {
   92|  31.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.3k|         }
   94|  31.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  31.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  31.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  31.3k|         else {
   92|  31.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.3k|         }
   94|  31.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  31.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  31.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  31.3k|         else {
   92|  31.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.3k|         }
   94|  31.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  31.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE5applyITtTpTyENS3_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.55k|      {
   65|  3.55k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.55k|         return Action< Rule >::apply( action_input, st... );
   67|  3.55k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.55k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  27.8k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  10.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.7k|         else {
   92|  10.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.7k|         }
   94|  10.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  10.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.7k|         else {
   92|  10.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.7k|         }
   94|  10.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  18.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  18.3k|         else {
   92|  18.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  18.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  18.3k|         }
   94|  18.3k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.53k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.53k|         else {
   92|  3.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.53k|         }
   94|  3.53k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.53k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.53k|         else {
   92|  3.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.53k|         }
   94|  3.53k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.53k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.53k|         else {
   92|  3.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.53k|         }
   94|  3.53k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.53k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.53k|         else {
   92|  3.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.53k|         }
   94|  3.53k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.53k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.53k|         else {
   92|  3.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.53k|         }
   94|  3.53k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.53k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.53k|         else {
   92|  3.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.53k|         }
   94|  3.53k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.33k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.33k|         else {
   92|  3.33k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.33k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.33k|         }
   94|  3.33k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.07k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.07k|         else {
   92|  3.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.07k|         }
   94|  3.07k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.88k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.88k|         else {
   92|  2.88k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.88k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.88k|         }
   94|  2.88k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.60k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.34k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.34k|         else {
   92|  2.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.34k|         }
   94|  2.34k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_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.39k|      {
   65|  1.39k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.39k|         return Action< Rule >::apply( action_input, st... );
   67|  1.39k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.53k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.53k|         else {
   92|  3.53k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.53k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.53k|         }
   94|  3.53k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.64k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.35k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.35k|         else {
   92|  2.35k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.35k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.35k|         }
   94|  2.35k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.30k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.81k|         else {
   92|  5.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.81k|         }
   94|  5.81k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.28k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.28k|         else {
   92|  2.28k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.28k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.28k|         }
   94|  2.28k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.04k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.04k|         else {
   92|  8.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.04k|         }
   94|  8.04k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.04k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.04k|         else {
   92|  8.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.04k|         }
   94|  8.04k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  6.87k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.87k|         else {
   92|  6.87k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.87k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.87k|         }
   94|  6.87k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  6.87k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.87k|         else {
   92|  6.87k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.87k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.87k|         }
   94|  6.87k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.78M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.78M|         else {
   92|  7.78M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.78M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.78M|         }
   94|  7.78M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.78M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.78M|         else {
   92|  7.78M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.78M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.78M|         }
   94|  7.78M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.78M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.78M|         else {
   92|  7.78M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.78M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.78M|         }
   94|  7.78M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.78M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.78M|         else {
   92|  7.78M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.78M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.78M|         }
   94|  7.78M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|   156k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_modeE2ETtTpTyENS4_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   156k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   156k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   156k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  71.9k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  71.9k|         else {
   92|  71.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  71.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  71.9k|         }
   94|  71.9k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  71.9k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  71.9k|         else {
   92|  71.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  71.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  71.9k|         }
   94|  71.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   143k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   143k|         else {
   92|   143k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   143k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   143k|         }
   94|   143k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  84.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  84.7k|         else {
   92|  84.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  84.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  84.7k|         }
   94|  84.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   118k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  25.2k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  25.2k|         else {
   92|  25.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  25.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  25.2k|         }
   94|  25.2k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  25.2k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  25.2k|         else {
   92|  25.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  25.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  25.2k|         }
   94|  25.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  59.5k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  59.5k|         else {
   92|  59.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  59.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  59.5k|         }
   94|  59.5k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.15k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.15k|         else {
   92|  2.15k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.15k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.15k|         }
   94|  2.15k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.62M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.62M|         else {
   92|  7.62M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.62M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.62M|         }
   94|  7.62M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_19parent_hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  6.62k|      {
   65|  6.62k|         const typename ParseInput::action_t action_input( begin, in );
   66|  6.62k|         return Action< Rule >::apply( action_input, st... );
   67|  6.62k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.90k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  28.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.90k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  28.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  28.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  28.1k|         else {
   92|  28.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.1k|         }
   94|  28.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  28.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  28.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  28.1k|         else {
   92|  28.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.1k|         }
   94|  28.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  28.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  28.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  28.1k|         else {
   92|  28.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  28.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  28.1k|         }
   94|  28.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  28.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5applyITtTpTyENS3_14serial_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  2.90k|      {
   65|  2.90k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.90k|         return Action< Rule >::apply( action_input, st... );
   67|  2.90k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.90k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  25.2k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  8.12k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.12k|         else {
   92|  8.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.12k|         }
   94|  8.12k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  8.12k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.12k|         else {
   92|  8.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.12k|         }
   94|  8.12k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  15.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  15.0k|         else {
   92|  15.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.0k|         }
   94|  15.0k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.89k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.89k|         else {
   92|  2.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.89k|         }
   94|  2.89k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.89k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.89k|         else {
   92|  2.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.89k|         }
   94|  2.89k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.89k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.89k|         else {
   92|  2.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.89k|         }
   94|  2.89k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  2.89k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.89k|         else {
   92|  2.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.89k|         }
   94|  2.89k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.89k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.89k|         else {
   92|  2.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.89k|         }
   94|  2.89k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.89k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.89k|         else {
   92|  2.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.89k|         }
   94|  2.89k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.67k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.25k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.19k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.85k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.85k|         else {
   92|  1.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.85k|         }
   94|  1.85k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_14serial_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.49k|      {
   65|  1.49k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.49k|         return Action< Rule >::apply( action_input, st... );
   67|  1.49k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.89k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.89k|         else {
   92|  2.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.89k|         }
   94|  2.89k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  3.58k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  1.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.81k|         else {
   92|  1.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.81k|         }
   94|  1.81k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.77k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.77k|         else {
   92|  1.77k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.77k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.77k|         }
   94|  1.77k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  3.71k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.71k|         else {
   92|  3.71k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.71k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.71k|         }
   94|  3.71k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.76k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.76k|         else {
   92|  1.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.76k|         }
   94|  1.76k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.25k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.25k|         else {
   92|  5.25k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.25k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.25k|         }
   94|  5.25k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.25k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.25k|         else {
   92|  5.25k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.25k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.25k|         }
   94|  5.25k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.69k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.69k|         else {
   92|  4.69k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.69k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.69k|         }
   94|  4.69k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  4.69k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.69k|         else {
   92|  4.69k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.69k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.69k|         }
   94|  4.69k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.50M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.50M|         else {
   92|  2.50M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.50M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.50M|         }
   94|  2.50M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.50M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.50M|         else {
   92|  2.50M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.50M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.50M|         }
   94|  2.50M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.50M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.50M|         else {
   92|  2.50M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.50M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.50M|         }
   94|  2.50M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.50M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.50M|         else {
   92|  2.50M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.50M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.50M|         }
   94|  2.50M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|  8.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.81k|         else {
   92|  8.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.81k|         }
   94|  8.81k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  8.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.81k|         else {
   92|  8.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.81k|         }
   94|  8.81k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.81k|         else {
   92|  8.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.81k|         }
   94|  8.81k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  8.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.81k|         else {
   92|  8.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.81k|         }
   94|  8.81k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  2.40k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  2.40k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.79k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.79k|         else {
   92|  4.79k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.79k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.79k|         }
   94|  4.79k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.41k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.41k|         else {
   92|  6.41k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.41k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.41k|         }
   94|  6.41k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  10.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.0k|         else {
   92|  10.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.0k|         }
   94|  10.0k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  3.07k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.07k|         else {
   92|  3.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.07k|         }
   94|  3.07k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  3.07k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.07k|         else {
   92|  3.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.07k|         }
   94|  3.07k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.33k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.33k|         else {
   92|  3.33k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.33k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.33k|         }
   94|  3.33k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    219|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    219|         else {
   92|    219|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    219|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    219|         }
   94|    219|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.49M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.49M|         else {
   92|  2.49M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.49M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.49M|         }
   94|  2.49M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_14serial_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  4.48k|      {
   65|  4.48k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.48k|         return Action< Rule >::apply( action_input, st... );
   67|  4.48k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.42k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  25.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.42k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  25.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  25.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  25.4k|         else {
   92|  25.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  25.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  25.4k|         }
   94|  25.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  25.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  25.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  25.4k|         else {
   92|  25.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  25.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  25.4k|         }
   94|  25.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  25.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  25.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  25.4k|         else {
   92|  25.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  25.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  25.4k|         }
   94|  25.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  25.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE5applyITtTpTyENS3_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.45k|      {
   65|  3.45k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.45k|         return Action< Rule >::apply( action_input, st... );
   67|  3.45k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.45k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  22.0k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  9.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.45k|         else {
   92|  9.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.45k|         }
   94|  9.45k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  9.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  9.45k|         else {
   92|  9.45k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.45k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.45k|         }
   94|  9.45k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  17.6k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  17.6k|         else {
   92|  17.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  17.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  17.6k|         }
   94|  17.6k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.43k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.43k|         else {
   92|  3.43k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.43k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.43k|         }
   94|  3.43k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.43k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.43k|         else {
   92|  3.43k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.43k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.43k|         }
   94|  3.43k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.43k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.43k|         else {
   92|  3.43k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.43k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.43k|         }
   94|  3.43k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.43k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.43k|         else {
   92|  3.43k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.43k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.43k|         }
   94|  3.43k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.43k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.43k|         else {
   92|  3.43k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.43k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.43k|         }
   94|  3.43k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.43k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.43k|         else {
   92|  3.43k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.43k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.43k|         }
   94|  3.43k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.22k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.22k|         else {
   92|  3.22k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.22k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.22k|         }
   94|  3.22k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.00k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.00k|         else {
   92|  3.00k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.00k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.00k|         }
   94|  3.00k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.61k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.61k|         else {
   92|  2.61k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.61k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.61k|         }
   94|  2.61k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.34k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.34k|         else {
   92|  2.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.34k|         }
   94|  2.34k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_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.30k|      {
   65|  1.30k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.30k|         return Action< Rule >::apply( action_input, st... );
   67|  1.30k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.43k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.43k|         else {
   92|  3.43k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.43k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.43k|         }
   94|  3.43k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.32k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.19k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.13k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.13k|         else {
   92|  2.13k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.13k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.13k|         }
   94|  2.13k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.70k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.70k|         else {
   92|  4.70k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.70k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.70k|         }
   94|  4.70k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.12k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.12k|         else {
   92|  2.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.12k|         }
   94|  2.12k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.86k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.86k|         else {
   92|  6.86k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.86k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.86k|         }
   94|  6.86k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.86k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.86k|         else {
   92|  6.86k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.86k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.86k|         }
   94|  6.86k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.81k|         else {
   92|  5.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.81k|         }
   94|  5.81k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  5.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.81k|         else {
   92|  5.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.81k|         }
   94|  5.81k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.19M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.19M|         else {
   92|  6.19M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.19M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.19M|         }
   94|  6.19M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.18M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.18M|         else {
   92|  6.18M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.18M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.18M|         }
   94|  6.18M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.18M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.18M|         else {
   92|  6.18M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.18M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.18M|         }
   94|  6.18M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.18M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.18M|         else {
   92|  6.18M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.18M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.18M|         }
   94|  6.18M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|  61.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  61.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  61.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  61.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  27.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  27.0k|         else {
   92|  27.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.0k|         }
   94|  27.0k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  27.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  27.0k|         else {
   92|  27.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.0k|         }
   94|  27.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  54.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  54.1k|         else {
   92|  54.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  54.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  54.1k|         }
   94|  54.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  34.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  34.7k|         else {
   92|  34.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  34.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  34.7k|         }
   94|  34.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  53.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  53.1k|         else {
   92|  53.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  53.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  53.1k|         }
   94|  53.1k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  13.9k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  13.9k|         else {
   92|  13.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.9k|         }
   94|  13.9k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  13.9k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  13.9k|         else {
   92|  13.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.9k|         }
   94|  13.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  20.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  20.8k|         else {
   92|  20.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  20.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  20.8k|         }
   94|  20.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    407|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    407|         else {
   92|    407|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    407|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    407|         }
   94|    407|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.12M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.12M|         else {
   92|  6.12M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.12M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.12M|         }
   94|  6.12M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_16via_port_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  5.52k|      {
   65|  5.52k|         const typename ParseInput::action_t action_input( begin, in );
   66|  5.52k|         return Action< Rule >::apply( action_input, st... );
   67|  5.52k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.78k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  22.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.78k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  22.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  22.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  22.3k|         else {
   92|  22.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.3k|         }
   94|  22.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  22.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  22.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  22.3k|         else {
   92|  22.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.3k|         }
   94|  22.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  22.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  22.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  22.3k|         else {
   92|  22.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.3k|         }
   94|  22.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  22.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE5applyITtTpTyENS3_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.38k|      {
   65|  3.38k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.38k|         return Action< Rule >::apply( action_input, st... );
   67|  3.38k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.38k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  18.9k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   170k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   170k|         else {
   92|   170k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   170k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   170k|         }
   94|   170k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   170k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   170k|         else {
   92|   170k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   170k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   170k|         }
   94|   170k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.61M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.61M|         else {
   92|  1.61M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.61M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.61M|         }
   94|  1.61M|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.38k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.38k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.38k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  3.38k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.38k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  3.38k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.38k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.38k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.14k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.94k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.60k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.27k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.77k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.77k|         else {
   92|  1.77k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.77k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.77k|         }
   94|  1.77k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_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.90k|      {
   65|  1.90k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.90k|         return Action< Rule >::apply( action_input, st... );
   67|  1.90k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.38k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.85k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.85k|         else {
   92|  4.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.85k|         }
   94|  4.85k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.45k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  2.45k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15interface_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.40k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15interface_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   165k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.40k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     48|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.40k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.21k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.16k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   166k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   166k|         else {
   92|   166k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   166k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   166k|         }
   94|   166k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   166k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   166k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   166k|         else {
   92|   166k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   166k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   166k|         }
   94|   166k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   498k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   836k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   836k|         else {
   92|   836k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   836k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   836k|         }
   94|   836k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   337k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   160k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   331k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   331k|         else {
   92|   331k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   331k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   331k|         }
   94|   331k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   331k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   331k|         else {
   92|   331k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   331k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   331k|         }
   94|   331k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   331k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   331k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   331k|         else {
   92|   331k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   331k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   331k|         }
   94|   331k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   159k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   159k|         else {
   92|   159k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   159k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   159k|         }
   94|   159k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   331k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|     54|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5applyITtTpTyENS3_22with_interface_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|   165k|      {
   65|   165k|         const typename ParseInput::action_t action_input( begin, in );
   66|   165k|         return Action< Rule >::apply( action_input, st... );
   67|   165k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   165k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.05k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.92k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    456|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.92k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  19.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.92k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  19.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  19.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  19.4k|         else {
   92|  19.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.4k|         }
   94|  19.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  19.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  19.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  19.4k|         else {
   92|  19.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.4k|         }
   94|  19.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  19.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  19.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  19.4k|         else {
   92|  19.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.4k|         }
   94|  19.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  19.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE5applyITtTpTyENS3_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|  2.84k|      {
   65|  2.84k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.84k|         return Action< Rule >::apply( action_input, st... );
   67|  2.84k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.83k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  16.6k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  8.74k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.74k|         else {
   92|  8.74k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.74k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.74k|         }
   94|  8.74k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  8.74k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  8.74k|         else {
   92|  8.74k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.74k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.74k|         }
   94|  8.74k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  17.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  17.3k|         else {
   92|  17.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  17.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  17.3k|         }
   94|  17.3k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.82k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.82k|         else {
   92|  2.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.82k|         }
   94|  2.82k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.82k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.82k|         else {
   92|  2.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.82k|         }
   94|  2.82k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.82k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.82k|         else {
   92|  2.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.82k|         }
   94|  2.82k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  2.82k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.82k|         else {
   92|  2.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.82k|         }
   94|  2.82k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.82k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.82k|         else {
   92|  2.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.82k|         }
   94|  2.82k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.82k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.82k|         else {
   92|  2.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.82k|         }
   94|  2.82k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.62k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.40k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.17k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.94k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.94k|         else {
   92|  1.94k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.94k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.94k|         }
   94|  1.94k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.67k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_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.35k|      {
   65|  1.35k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.35k|         return Action< Rule >::apply( action_input, st... );
   67|  1.35k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.82k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.82k|         else {
   92|  2.82k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.82k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.82k|         }
   94|  2.82k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.16k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.12k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.12k|         else {
   92|  2.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.12k|         }
   94|  2.12k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.05k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.55k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.55k|         else {
   92|  4.55k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.55k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.55k|         }
   94|  4.55k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.04k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.91k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.91k|         else {
   92|  5.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.91k|         }
   94|  5.91k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.91k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.91k|         else {
   92|  5.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.91k|         }
   94|  5.91k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  5.16k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.16k|         else {
   92|  5.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.16k|         }
   94|  5.16k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  5.16k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.16k|         else {
   92|  5.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.16k|         }
   94|  5.16k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.34M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.34M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.34M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.34M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_modeE1ETtTpTyENS6_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|  92.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  92.0k|         else {
   92|  92.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  92.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  92.0k|         }
   94|  92.0k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  92.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  92.0k|         else {
   92|  92.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  92.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  92.0k|         }
   94|  92.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  92.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  92.0k|         else {
   92|  92.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  92.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  92.0k|         }
   94|  92.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  92.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  92.0k|         else {
   92|  92.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  92.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  92.0k|         }
   94|  92.0k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  21.2k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  21.2k|         else {
   92|  21.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  21.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  21.2k|         }
   94|  21.2k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  21.2k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  21.2k|         else {
   92|  21.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  21.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  21.2k|         }
   94|  21.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  42.5k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  42.5k|         else {
   92|  42.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.5k|         }
   94|  42.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  70.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  70.7k|         else {
   92|  70.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  70.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  70.7k|         }
   94|  70.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   104k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   104k|         else {
   92|   104k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   104k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   104k|         }
   94|   104k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  29.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  29.8k|         else {
   92|  29.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.8k|         }
   94|  29.8k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  29.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  29.8k|         else {
   92|  29.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.8k|         }
   94|  29.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  40.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  40.8k|         else {
   92|  40.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  40.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  40.8k|         }
   94|  40.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.02k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.02k|         else {
   92|  1.02k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.02k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.02k|         }
   94|  1.02k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.24M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.24M|         else {
   92|  7.24M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.24M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.24M|         }
   94|  7.24M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_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.92k|      {
   65|  4.92k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.92k|         return Action< Rule >::apply( action_input, st... );
   67|  4.92k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.23k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  16.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.23k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  16.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  16.9k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  16.9k|         else {
   92|  16.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.9k|         }
   94|  16.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  16.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  16.9k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  16.9k|         else {
   92|  16.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.9k|         }
   94|  16.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  16.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  16.9k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  16.9k|         else {
   92|  16.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.9k|         }
   94|  16.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  16.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5applyITtTpTyENS3_17condition_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  5.93k|      {
   65|  5.93k|         const typename ParseInput::action_t action_input( begin, in );
   66|  5.93k|         return Action< Rule >::apply( action_input, st... );
   67|  5.93k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  5.93k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  10.9k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   644k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   644k|         else {
   92|   644k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   644k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   644k|         }
   94|   644k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   644k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   644k|         else {
   92|   644k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   644k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   644k|         }
   94|   644k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   679k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   679k|         else {
   92|   679k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   679k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   679k|         }
   94|   679k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  5.90k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.90k|         else {
   92|  5.90k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.90k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.90k|         }
   94|  5.90k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  5.90k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.90k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.90k|         else {
   92|  5.90k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.90k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.90k|         }
   94|  5.90k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  5.90k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  5.90k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.90k|         else {
   92|  5.90k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.90k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.90k|         }
   94|  5.90k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  5.90k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.90k|         else {
   92|  5.90k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.90k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.90k|         }
   94|  5.90k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.90k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.90k|         else {
   92|  5.90k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.90k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.90k|         }
   94|  5.90k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.90k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.90k|         else {
   92|  5.90k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.90k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.90k|         }
   94|  5.90k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.82k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.61k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.61k|         else {
   92|  5.61k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.61k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.61k|         }
   94|  5.61k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.39k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.39k|         else {
   92|  5.39k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.39k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.39k|         }
   94|  5.39k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.09k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.09k|         else {
   92|  5.09k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.09k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.09k|         }
   94|  5.09k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.81k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.81k|         else {
   92|  4.81k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.81k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.81k|         }
   94|  4.81k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_17condition_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.28k|      {
   65|  1.28k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.28k|         return Action< Rule >::apply( action_input, st... );
   67|  1.28k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.90k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  5.90k|         else {
   92|  5.90k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.90k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.90k|         }
   94|  5.90k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  6.21k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.21k|         else {
   92|  6.21k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.21k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.21k|         }
   94|  6.21k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  3.73k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.73k|         else {
   92|  3.73k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.73k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.73k|         }
   94|  3.73k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.73k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser9conditionEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  3.59k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.59k|         else {
   92|  3.59k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.59k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.59k|         }
   94|  3.59k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   637k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   637k|         else {
   92|   637k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   637k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   637k|         }
   94|   637k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.48k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     41|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.48k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.48k|         else {
   92|  2.48k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.48k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.48k|         }
   94|  2.48k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  1.86k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  2.82k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   641k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   641k|         else {
   92|   641k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   641k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   641k|         }
   94|   641k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   641k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   641k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   641k|         else {
   92|   641k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   641k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   641k|         }
   94|   641k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   641k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   641k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   641k|         else {
   92|   641k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   641k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   641k|         }
   94|   641k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   641k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|    505|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   641k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   641k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   641k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   641k|         else {
   92|   641k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   641k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   641k|         }
   94|   641k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   641k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   641k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   641k|         else {
   92|   641k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   641k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   641k|         }
   94|   641k|      }
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   641k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   640k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.25k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   87|   640k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   640k|         else {
   92|   640k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   640k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   640k|         }
   94|   640k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   640k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  29.4M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  29.4M|         else {
   92|  29.4M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.4M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.4M|         }
   94|  29.4M|      }
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  29.4M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  28.8M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   640k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   640k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   640k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.25k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   640k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   640k|         else {
   92|   640k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   640k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   640k|         }
   94|   640k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   640k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   640k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   640k|         else {
   92|   640k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   640k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   640k|         }
   94|   640k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   640k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   640k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   640k|         else {
   92|   640k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   640k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   640k|         }
   94|   640k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   640k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  35.4k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   605k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  35.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  35.4k|         else {
   92|  35.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.4k|         }
   94|  35.4k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  35.4k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  35.4k|         else {
   92|  35.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.4k|         }
   94|  35.4k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   36|  35.4k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  44.7M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  44.7M|         else {
   92|  44.7M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.7M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.7M|         }
   94|  44.7M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  44.7M|      {}
_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|  44.7M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  44.7M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  44.7M|         else {
   92|  44.7M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.7M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.7M|         }
   94|  44.7M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  44.7M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  44.7M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  44.7M|         else {
   92|  44.7M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.7M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.7M|         }
   94|  44.7M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  44.7M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  44.7M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  44.7M|         else {
   92|  44.7M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.7M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.7M|         }
   94|  44.7M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|   174k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   174k|         else {
   92|   174k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   174k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   174k|         }
   94|   174k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   174k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   174k|         else {
   92|   174k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   174k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   174k|         }
   94|   174k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   174k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   174k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   174k|         else {
   92|   174k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   174k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   174k|         }
   94|   174k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   174k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   174k|         else {
   92|   174k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   174k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   174k|         }
   94|   174k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  29.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  29.0k|         else {
   92|  29.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.0k|         }
   94|  29.0k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  29.0k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  29.0k|         else {
   92|  29.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.0k|         }
   94|  29.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  58.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  58.1k|         else {
   92|  58.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  58.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  58.1k|         }
   94|  58.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   145k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   145k|         else {
   92|   145k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   145k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   145k|         }
   94|   145k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   181k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   181k|         else {
   92|   181k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   181k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   181k|         }
   94|   181k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  29.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  29.1k|         else {
   92|  29.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.1k|         }
   94|  29.1k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  29.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  29.1k|         else {
   92|  29.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.1k|         }
   94|  29.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   116k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_5ascii3oneIJLc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    593|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    593|         else {
   92|    593|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    593|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    593|         }
   94|    593|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   174k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     62|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   48|     62|      {
   49|     62|#if defined( __cpp_exceptions )
   50|     62|         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|     62|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   174k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  44.5M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  44.5M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  44.5M|         else {
   92|  44.5M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.5M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.5M|         }
   94|  44.5M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  44.7M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    255|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   40|  35.0k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   44|    255|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   48|    255|      {
   49|    255|#if defined( __cpp_exceptions )
   50|    255|         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|    255|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  35.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   605k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   640k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5applyITtTpTyENS3_17condition_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|   640k|      {
   65|   640k|         const typename ParseInput::action_t action_input( begin, in );
   66|   640k|         return Action< Rule >::apply( action_input, st... );
   67|   640k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   638k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.25k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.85k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    723|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.85k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  11.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.85k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  11.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  11.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  11.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  11.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  11.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  11.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_labelEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  11.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.24k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.49k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  10.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.3k|         else {
   92|  10.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.3k|         }
   94|  10.3k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  10.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.3k|         else {
   92|  10.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.3k|         }
   94|  10.3k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  16.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  16.7k|         else {
   92|  16.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.7k|         }
   94|  16.7k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.22k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.22k|         else {
   92|  4.22k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.22k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.22k|         }
   94|  4.22k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.22k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.22k|         else {
   92|  4.22k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.22k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.22k|         }
   94|  4.22k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.22k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.22k|         else {
   92|  4.22k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.22k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.22k|         }
   94|  4.22k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS5_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS4_4RuleEEEEbRT3_DpOT4_:
   87|  4.22k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.22k|         else {
   92|  4.22k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.22k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.22k|         }
   94|  4.22k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.22k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.22k|         else {
   92|  4.22k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.22k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.22k|         }
   94|  4.22k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.22k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.22k|         else {
   92|  4.22k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.22k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.22k|         }
   94|  4.22k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.94k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.94k|         else {
   92|  3.94k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.94k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.94k|         }
   94|  3.94k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.69k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.69k|         else {
   92|  3.69k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.69k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.69k|         }
   94|  3.69k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.47k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  3.47k|         else {
   92|  3.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.47k|         }
   94|  3.47k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.27k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.84k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.84k|         else {
   92|  2.84k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.84k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.84k|         }
   94|  2.84k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_13label_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  1.62k|      {
   65|  1.62k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.62k|         return Action< Rule >::apply( action_input, st... );
   67|  1.62k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.22k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.22k|         else {
   92|  4.22k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.22k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.22k|         }
   94|  4.22k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.85k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.85k|         else {
   92|  4.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.85k|         }
   94|  4.85k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  2.46k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.46k|         else {
   92|  2.46k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.46k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.46k|         }
   94|  2.46k|      }
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  2.40k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser12string_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  4.51k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  4.51k|         else {
   92|  4.51k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.51k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.51k|         }
   94|  4.51k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.38k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  2.38k|         else {
   92|  2.38k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.38k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.38k|         }
   94|  2.38k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.00k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.00k|         else {
   92|  7.00k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.00k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.00k|         }
   94|  7.00k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.00k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  7.00k|         else {
   92|  7.00k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.00k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.00k|         }
   94|  7.00k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  6.14k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.14k|         else {
   92|  6.14k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.14k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.14k|         }
   94|  6.14k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  6.14k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  6.14k|         else {
   92|  6.14k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.14k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.14k|         }
   94|  6.14k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  10.6M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.6M|         else {
   92|  10.6M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.6M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.6M|         }
   94|  10.6M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  10.6M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.6M|         else {
   92|  10.6M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.6M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.6M|         }
   94|  10.6M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  10.6M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.6M|         else {
   92|  10.6M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.6M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.6M|         }
   94|  10.6M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  10.6M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.6M|         else {
   92|  10.6M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.6M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.6M|         }
   94|  10.6M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|   110k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   110k|         else {
   92|   110k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   110k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   110k|         }
   94|   110k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   110k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   110k|         else {
   92|   110k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   110k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   110k|         }
   94|   110k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   110k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   110k|         else {
   92|   110k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   110k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   110k|         }
   94|   110k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   110k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   110k|         else {
   92|   110k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   110k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   110k|         }
   94|   110k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  42.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  42.1k|         else {
   92|  42.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.1k|         }
   94|  42.1k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  42.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  42.1k|         else {
   92|  42.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.1k|         }
   94|  42.1k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  84.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  84.3k|         else {
   92|  84.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  84.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  84.3k|         }
   94|  84.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  68.1k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  68.1k|         else {
   92|  68.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  68.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  68.1k|         }
   94|  68.1k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   109k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   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_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  35.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  35.3k|         else {
   92|  35.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.3k|         }
   94|  35.3k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  35.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  35.3k|         else {
   92|  35.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.3k|         }
   94|  35.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  32.7k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  32.7k|         else {
   92|  32.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  32.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  32.7k|         }
   94|  32.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.69k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  1.69k|         else {
   92|  1.69k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.69k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.69k|         }
   94|  1.69k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  10.4M|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  10.4M|         else {
   92|  10.4M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.4M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.4M|         }
   94|  10.4M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5applyITtTpTyENS3_13label_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  5.83k|      {
   65|  5.83k|         const typename ParseInput::action_t action_input( begin, in );
   66|  5.83k|         return Action< Rule >::apply( action_input, st... );
   67|  5.83k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.53k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.85k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.53k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.85k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  29.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  7.85k|      {}
_ZN3tao5pegtl6normalINS0_8internal4starINS0_4plusINS0_5ascii5blankEJEEEJN8usbguard10RuleParser15rule_attributesEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS9_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  26.2k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  26.2k|         else {
   92|  26.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  26.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  26.2k|         }
   94|  26.2k|      }
_ZN3tao5pegtl6normalINS0_8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser15rule_attributesEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  29.3k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  29.3k|         else {
   92|  29.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.3k|         }
   94|  29.3k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  25.9k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|  6.47k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS8_4RuleEEEEvRKT_DpOT0_:
   40|  33.6k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  33.6k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  33.6k|         else {
   92|  33.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.6k|         }
   94|  33.6k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  33.6k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  33.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  33.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    104|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  33.6k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    104|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEvRKT_DpOT0_:
   40|  33.8k|      {}
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  33.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  33.8k|         else {
   92|  33.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.8k|         }
   94|  33.8k|      }
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  33.8k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|  33.8k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|  33.8k|         else {
   92|  33.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.8k|         }
   94|  33.8k|      }
_ZN3tao5pegtl6normalINS0_3eofEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   48|  4.55k|      {
   49|  4.55k|#if defined( __cpp_exceptions )
   50|  4.55k|         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.55k|      }
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  29.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  29.2k|      {}

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

_ZN3tao5pegtl8internal11parse_errorC2EPKc:
   31|  9.18k|            : m_msg( msg )
   32|  9.18k|         {}
_ZNK3tao5pegtl8internal11parse_error4whatEv:
   35|  9.18k|         {
   36|  9.18k|            return m_msg.c_str();
   37|  9.18k|         }
_ZNK3tao5pegtl8internal11parse_error9positionsEv:
   45|  9.18k|         {
   46|  9.18k|            return m_positions;
   47|  9.18k|         }
_ZN3tao5pegtl8internal11parse_error12add_positionEONS0_8positionE:
   50|  9.18k|         {
   51|  9.18k|            const auto prefix = to_string( p );
   52|  9.18k|            m_msg = prefix + ": " + m_msg;
   53|  9.18k|            m_prefix += prefix.size() + 2;
   54|  9.18k|            m_positions.emplace_back( std::move( p ) );
   55|  9.18k|         }
_ZN3tao5pegtl11parse_errorC2EPKcNS0_8positionE:
   68|  9.18k|         : std::runtime_error( msg ),
   69|  9.18k|           m_impl( std::make_shared< internal::parse_error >( msg ) )
   70|  9.18k|      {
   71|  9.18k|         m_impl->add_position( std::move( p ) );
   72|  9.18k|      }
_ZN3tao5pegtl11parse_errorC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_8positionE:
   75|  6.81k|         : parse_error( msg.c_str(), std::move( p ) )
   76|  6.81k|      {}
_ZNK3tao5pegtl11parse_error4whatEv:
   89|  9.18k|      {
   90|  9.18k|         return m_impl->what();
   91|  9.18k|      }
_ZNK3tao5pegtl11parse_error9positionsEv:
   99|  9.18k|      {
  100|  9.18k|         return m_impl->positions();
  101|  9.18k|      }
_ZN3tao5pegtl11parse_errorC2INS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEEERKSE_RKT_:
   85|  6.81k|         : parse_error( msg, in.position() )
   86|  6.81k|      {}
_ZN3tao5pegtl11parse_errorC2INS0_8internal12action_inputINS0_12memory_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEEEPKcRKT_:
   80|  2.36k|         : parse_error( msg, in.position() )
   81|  2.36k|      {}

_ZN3tao5pegtl8positionC2EOS1_:
   28|  16.0k|         : byte( p.byte ),
   29|  16.0k|           line( p.line ),
   30|  16.0k|           column( p.column ),
   31|  16.0k|           source( std::move( p.source ) )
   32|  16.0k|      {}
_ZN3tao5pegtllsERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERKNS0_8positionE:
   85|  9.18k|   {
   86|  9.18k|      return os << p.source << ':' << p.line << ':' << p.column;
   87|  9.18k|   }
_ZN3tao5pegtl9to_stringERKNS0_8positionE:
   90|  9.18k|   {
   91|  9.18k|      std::ostringstream oss;
   92|  9.18k|      oss << p;
   93|  9.18k|      return std::move( oss ).str();
   94|  9.18k|   }
_ZN3tao5pegtl8positionC2IRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKNS0_8internal8iteratorEOT_:
   52|  9.18k|         : byte( in_iter.byte ),
   53|  9.18k|           line( in_iter.line ),
   54|  9.18k|           column( in_iter.column ),
   55|  9.18k|           source( std::forward< T >( in_source ) )
   56|  9.18k|      {}
_ZN3tao5pegtl8positionD2Ev:
   66|  25.1k|      ~position() = default;

_ZN3tao5pegtl12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEED2Ev:
   53|  38.4k|      ~string_input() = default;
_ZN3tao5pegtl8internal13string_holderD2Ev:
   31|  38.4k|         ~string_holder() = default;
_ZN3tao5pegtl12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEC2IRKSC_SG_JEEEOT_OT0_DpOT1_:
   46|  38.4k|         : internal::string_holder( std::forward< V >( in_data ) ),
   47|  38.4k|           memory_input< P, Eol, Source >( data.data(), data.size(), std::forward< T >( in_source ), std::forward< Ts >( ts )... )
   48|  38.4k|      {}
_ZN3tao5pegtl8internal13string_holderC2IRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEOT_:
   25|  38.4k|            : data( std::forward< T >( in_data ) )
   26|  38.4k|         {}