_ZN8usbguard14stringToNumberIhEET_RKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEi:
  294|   372k|  {
  295|   372k|    const unsigned int num = stringToNumber<unsigned int>(s, base);
  296|   372k|    return (uint8_t)num;
  297|   372k|  }

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

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

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

_ZN8usbguard18LocaltimeConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   36|  3.33k|    : RuleConditionBase("localtime", time_range, negated)
   37|  3.33k|  {
   38|  3.33k|    std::string time_begin;
   39|  3.33k|    std::string time_end;
   40|  3.33k|    const size_t dash_pos = time_range.find('-');
   41|       |
   42|  3.33k|    if (dash_pos == std::string::npos) {
  ------------------
  |  Branch (42:9): [True: 859, False: 2.47k]
  ------------------
   43|    859|      time_begin = time_range;
   44|    859|    }
   45|  2.47k|    else {
   46|  2.47k|      time_begin = time_range.substr(0, dash_pos);
   47|  2.47k|      time_end = time_range.substr(dash_pos + 1);
   48|  2.47k|    }
   49|       |
   50|  3.33k|    _daytime_begin = stringToDaytime(time_begin);
   51|       |
   52|  3.33k|    if (!time_end.empty()) {
  ------------------
  |  Branch (52:9): [True: 1.37k, False: 1.95k]
  ------------------
   53|  1.37k|      _daytime_end = stringToDaytime(time_end);
   54|  1.37k|    }
   55|  1.95k|    else {
   56|  1.95k|      _daytime_end = _daytime_begin;
   57|  1.95k|    }
   58|       |
   59|  3.33k|    if (_daytime_begin > _daytime_end) {
  ------------------
  |  Branch (59:9): [True: 27, False: 3.30k]
  ------------------
   60|     27|      throw Exception("LocaltimeCondition", "Invalid time range (begin > end)", time_range);
   61|     27|    }
   62|  3.33k|  }
_ZN8usbguard18LocaltimeConditionC2ERKS0_:
   65|  4.82k|    : RuleConditionBase(rhs)
   66|  4.82k|  {
   67|  4.82k|    _daytime_begin = rhs._daytime_begin;
   68|  4.82k|    _daytime_end = rhs._daytime_end;
   69|  4.82k|  }
_ZNK8usbguard18LocaltimeCondition5cloneEv:
   82|  4.82k|  {
   83|  4.82k|    return new LocaltimeCondition(*this);
   84|  4.82k|  }
_ZN8usbguard18LocaltimeCondition15stringToDaytimeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  112|  4.71k|  {
  113|  4.71k|    USBGUARD_LOG(Trace) << "string=" << string;
  ------------------
  |  |  299|  4.71k|  if (USBGUARD_LOGGER.isEnabled(usbguard::LogStream::Level::level))                                                            \
  |  |  ------------------
  |  |  |  |  294|  4.71k|#define USBGUARD_LOGGER usbguard::G_logger
  |  |  ------------------
  |  |  |  Branch (299:7): [True: 0, False: 4.71k]
  |  |  ------------------
  |  |  300|  4.71k|  USBGUARD_LOGGER(USBGUARD_SOURCE_FILE, __LINE__, USBGUARD_FUNCTION, usbguard::LogStream::Level::level)
  |  |  ------------------
  |  |  |  |  294|      0|#define USBGUARD_LOGGER usbguard::G_logger
  |  |  ------------------
  |  |                 USBGUARD_LOGGER(USBGUARD_SOURCE_FILE, __LINE__, USBGUARD_FUNCTION, usbguard::LogStream::Level::level)
  |  |  ------------------
  |  |  |  |  289|       |  #define USBGUARD_SOURCE_FILE __BASE_FILE__
  |  |  ------------------
  |  |                 USBGUARD_LOGGER(USBGUARD_SOURCE_FILE, __LINE__, USBGUARD_FUNCTION, usbguard::LogStream::Level::level)
  |  |  ------------------
  |  |  |  |  296|      0|#define USBGUARD_FUNCTION __func__
  |  |  ------------------
  ------------------
  114|  4.71k|    struct ::tm tm = {};
  115|       |
  116|  4.71k|    if (::strptime(string.c_str(), "%H:%M:%s", &tm) == nullptr) {
  ------------------
  |  Branch (116:9): [True: 3.88k, False: 832]
  ------------------
  117|  3.88k|      if (::strptime(string.c_str(), "%H:%M", &tm) == nullptr) {
  ------------------
  |  Branch (117:11): [True: 183, False: 3.69k]
  ------------------
  118|    183|        throw Exception("LocaltimeCondition", "Invalid time or range format", string);
  119|    183|      }
  120|  3.88k|    }
  121|       |
  122|  4.52k|    USBGUARD_LOG(Trace) << "tm=" << tmToString(&tm);
  ------------------
  |  |  299|  4.52k|  if (USBGUARD_LOGGER.isEnabled(usbguard::LogStream::Level::level))                                                            \
  |  |  ------------------
  |  |  |  |  294|  4.52k|#define USBGUARD_LOGGER usbguard::G_logger
  |  |  ------------------
  |  |  |  Branch (299:7): [True: 0, False: 4.52k]
  |  |  ------------------
  |  |  300|  4.52k|  USBGUARD_LOGGER(USBGUARD_SOURCE_FILE, __LINE__, USBGUARD_FUNCTION, usbguard::LogStream::Level::level)
  |  |  ------------------
  |  |  |  |  294|      0|#define USBGUARD_LOGGER usbguard::G_logger
  |  |  ------------------
  |  |                 USBGUARD_LOGGER(USBGUARD_SOURCE_FILE, __LINE__, USBGUARD_FUNCTION, usbguard::LogStream::Level::level)
  |  |  ------------------
  |  |  |  |  289|       |  #define USBGUARD_SOURCE_FILE __BASE_FILE__
  |  |  ------------------
  |  |                 USBGUARD_LOGGER(USBGUARD_SOURCE_FILE, __LINE__, USBGUARD_FUNCTION, usbguard::LogStream::Level::level)
  |  |  ------------------
  |  |  |  |  296|      0|#define USBGUARD_FUNCTION __func__
  |  |  ------------------
  ------------------
  123|  4.52k|    return tm.tm_sec + 60 * tm.tm_min + 60 * 60 * tm.tm_hour;
  124|  4.71k|  }

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

_ZN8usbguard20RuleAppliedConditionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   37|  2.64k|    : RuleConditionBase("rule-applied", elapsed_time, negated)
   38|  2.64k|  {
   39|  2.64k|    _elapsed_time = std::chrono::steady_clock::duration(stringToSeconds(elapsed_time));
   40|  2.64k|  }
_ZN8usbguard20RuleAppliedConditionC2ERKS0_:
   43|  4.59k|    : RuleConditionBase(rhs),
   44|  4.59k|      _elapsed_time(rhs._elapsed_time)
   45|  4.59k|  {
   46|  4.59k|  }
_ZNK8usbguard20RuleAppliedCondition5cloneEv:
   67|  4.59k|  {
   68|  4.59k|    return new RuleAppliedCondition(*this);
   69|  4.59k|  }
_ZN8usbguard20RuleAppliedCondition15stringToSecondsERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   72|  2.64k|  {
   73|  2.64k|    struct ::tm tm = {};
   74|       |
   75|  2.64k|    if (string.empty() || string == "") {
  ------------------
  |  Branch (75:9): [True: 657, False: 1.98k]
  |  Branch (75:27): [True: 0, False: 1.98k]
  ------------------
   76|    657|      return 0;
   77|    657|    }
   78|       |
   79|  1.98k|    if (::strptime(string.c_str(), "%H:%M:%s", &tm) == nullptr) {
  ------------------
  |  Branch (79:9): [True: 1.72k, False: 259]
  ------------------
   80|  1.72k|      if (::strptime(string.c_str(), "%H:%M", &tm) == nullptr) {
  ------------------
  |  Branch (80:11): [True: 1.46k, False: 263]
  ------------------
   81|  1.46k|        if (::strptime(string.c_str(), "%s", &tm) == nullptr) {
  ------------------
  |  Branch (81:13): [True: 4, False: 1.45k]
  ------------------
   82|      4|          throw std::runtime_error("Invalid time string. Expecing either HH:MM or HH:MM:SS format.");
   83|      4|        }
   84|  1.46k|      }
   85|  1.72k|    }
   86|       |
   87|  1.97k|    return tm.tm_sec + 60 * tm.tm_min + 60 * 60 * tm.tm_hour;
   88|  1.98k|  }

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

_ZN8usbguard10RuleParser19rule_parser_actionsINS0_7commentEE6apply0ERNS_4RuleE:
   55|  16.4k|      {
   56|  16.4k|        if (rule.getTarget() == Rule::Target::Invalid) {
  ------------------
  |  Branch (56:13): [True: 27, False: 16.4k]
  ------------------
   57|     27|          rule.setTarget(Rule::Target::Empty);
   58|     27|        }
   59|  16.4k|      }
_ZN8usbguard10RuleParser19rule_parser_actionsINS0_6targetEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
   64|  46.8k|      {
   65|  46.8k|        try {
   66|  46.8k|          rule.setTarget(Rule::targetFromString(in.string()));
   67|  46.8k|        } catch (const std::exception& ex) {
   68|      0|          throw tao::pegtl::parse_error(ex.what(), in);
   69|      0|        }
   70|  46.8k|      }
_ZN8usbguard10RuleParser19rule_parser_actionsINS0_9device_idEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
   75|  3.63k|      {
   76|  3.63k|        try {
   77|  3.63k|          std::vector<std::string> tokens;
   78|  3.63k|          tokenizeString(in.string(), tokens, ":");
   79|  3.63k|          const USBDeviceID device_id(tokens[0], tokens[1]);
   80|  3.63k|          rule.setDeviceID(device_id);
   81|  3.63k|        } catch (const std::exception& ex) {
   82|      3|          throw tao::pegtl::parse_error(ex.what(), in);
   83|      3|        }
   84|  3.63k|      }
_ZN8usbguard10RuleParser10id_actionsINS0_6str_idEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  130|  3.59k|      {
  131|  3.59k|        if (!rule.attributeDeviceID().empty()) {
  ------------------
  |  Branch (131:13): [True: 5, False: 3.58k]
  ------------------
  132|      5|          throw tao::pegtl::parse_error("id attribute already defined", in);
  133|      5|        }
  134|  3.59k|      }
_ZN8usbguard10RuleParser10id_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  153|  1.74k|      {
  154|  1.74k|        try {
  155|  1.74k|          rule.attributeDeviceID().setSetOperator(Rule::setOperatorFromString(in.string()));
  156|  1.74k|        } catch (const std::exception& ex) {
  157|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  158|      0|        }
  159|  1.74k|      }
_ZN8usbguard10RuleParser10id_actionsINS0_15device_id_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  139|   811k|      {
  140|   811k|        try {
  141|   811k|          std::vector<std::string> tokens;
  142|   811k|          tokenizeString(in.string(), tokens, ":");
  143|   811k|          const USBDeviceID device_id(tokens[0], tokens[1]);
  144|   811k|          rule.attributeDeviceID().append(device_id);
  145|   811k|        } catch (const std::exception& ex) {
  146|      6|          throw tao::pegtl::parse_error(ex.what(), in);
  147|      6|        }
  148|   811k|      }
_ZN8usbguard10RuleParser12name_actionsINS0_8str_nameEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
   97|  4.06k|      {
   98|  4.06k|        if (!rule.attributeName().empty()) {
  ------------------
  |  Branch (98:13): [True: 4, False: 4.06k]
  ------------------
   99|      4|          throw tao::pegtl::parse_error("name attribute already defined", in);
  100|      4|        }
  101|  4.06k|      }
_ZN8usbguard10RuleParser12name_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  117|  2.14k|      {
  118|  2.14k|        try {
  119|  2.14k|          rule.attributeName().setSetOperator(Rule::setOperatorFromString(in.string()));
  120|  2.14k|        } catch (const std::exception& ex) {
  121|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  122|      0|        }
  123|  2.14k|      }
_ZN8usbguard10RuleParser12name_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  106|   348k|      {
  107|   348k|        try {
  108|   348k|          rule.attributeName().append(stringValueFromRule(in.string()));
  109|   348k|        } catch (const std::exception& ex) {
  110|     84|          throw tao::pegtl::parse_error(ex.what(), in);
  111|     84|        }
  112|   348k|      }
RuleParser.cpp:_ZN8usbguard10RuleParserL19stringValueFromRuleERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   88|   408k|    {
   89|   408k|      const std::string string_raw(value.substr(1, value.size() - 2));
   90|   408k|      return Utility::unescapeString(string_raw);
   91|   408k|    }
_ZN8usbguard10RuleParser12hash_actionsINS0_8str_hashEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  166|  6.07k|      {
  167|  6.07k|        if (!rule.attributeHash().empty()) {
  ------------------
  |  Branch (167:13): [True: 4, False: 6.06k]
  ------------------
  168|      4|          throw tao::pegtl::parse_error("hash attribute already defined", in);
  169|      4|        }
  170|  6.07k|      }
_ZN8usbguard10RuleParser12hash_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  186|  3.61k|      {
  187|  3.61k|        try {
  188|  3.61k|          rule.attributeHash().setSetOperator(Rule::setOperatorFromString(in.string()));
  189|  3.61k|        } catch (const std::exception& ex) {
  190|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  191|      0|        }
  192|  3.61k|      }
_ZN8usbguard10RuleParser12hash_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  175|  30.2k|      {
  176|  30.2k|        try {
  177|  30.2k|          rule.attributeHash().append(stringValueFromRule(in.string()));
  178|  30.2k|        } catch (const std::exception& ex) {
  179|     64|          throw tao::pegtl::parse_error(ex.what(), in);
  180|     64|        }
  181|  30.2k|      }
_ZN8usbguard10RuleParser19parent_hash_actionsINS0_15str_parent_hashEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  199|  2.99k|      {
  200|  2.99k|        if (!rule.attributeParentHash().empty()) {
  ------------------
  |  Branch (200:13): [True: 3, False: 2.99k]
  ------------------
  201|      3|          throw tao::pegtl::parse_error("parent-hash attribute already defined", in);
  202|      3|        }
  203|  2.99k|      }
_ZN8usbguard10RuleParser19parent_hash_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  219|  1.26k|      {
  220|  1.26k|        try {
  221|  1.26k|          rule.attributeParentHash().setSetOperator(Rule::setOperatorFromString(in.string()));
  222|  1.26k|        } catch (const std::exception& ex) {
  223|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  224|      0|        }
  225|  1.26k|      }
_ZN8usbguard10RuleParser19parent_hash_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  208|  4.84k|      {
  209|  4.84k|        try {
  210|  4.84k|          rule.attributeParentHash().append(stringValueFromRule(in.string()));
  211|  4.84k|        } catch (const std::exception& ex) {
  212|     36|          throw tao::pegtl::parse_error(ex.what(), in);
  213|     36|        }
  214|  4.84k|      }
_ZN8usbguard10RuleParser14serial_actionsINS0_10str_serialEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  232|  3.44k|      {
  233|  3.44k|        if (!rule.attributeSerial().empty()) {
  ------------------
  |  Branch (233:13): [True: 3, False: 3.44k]
  ------------------
  234|      3|          throw tao::pegtl::parse_error("serial attribute already defined", in);
  235|      3|        }
  236|  3.44k|      }
_ZN8usbguard10RuleParser14serial_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  252|  1.38k|      {
  253|  1.38k|        try {
  254|  1.38k|          rule.attributeSerial().setSetOperator(Rule::setOperatorFromString(in.string()));
  255|  1.38k|        } catch (const std::exception& ex) {
  256|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  257|      0|        }
  258|  1.38k|      }
_ZN8usbguard10RuleParser14serial_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  241|  5.39k|      {
  242|  5.39k|        try {
  243|  5.39k|          rule.attributeSerial().append(stringValueFromRule(in.string()));
  244|  5.39k|        } catch (const std::exception& ex) {
  245|     19|          throw tao::pegtl::parse_error(ex.what(), in);
  246|     19|        }
  247|  5.39k|      }
_ZN8usbguard10RuleParser16via_port_actionsINS0_12str_via_portEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  331|  3.04k|      {
  332|  3.04k|        if (!rule.attributeViaPort().empty()) {
  ------------------
  |  Branch (332:13): [True: 2, False: 3.04k]
  ------------------
  333|      2|          throw tao::pegtl::parse_error("via-port attribute already defined", in);
  334|      2|        }
  335|  3.04k|      }
_ZN8usbguard10RuleParser16via_port_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  351|  1.22k|      {
  352|  1.22k|        try {
  353|  1.22k|          rule.attributeViaPort().setSetOperator(Rule::setOperatorFromString(in.string()));
  354|  1.22k|        } catch (const std::exception& ex) {
  355|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  356|      0|        }
  357|  1.22k|      }
_ZN8usbguard10RuleParser16via_port_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  340|  4.62k|      {
  341|  4.62k|        try {
  342|  4.62k|          rule.attributeViaPort().append(stringValueFromRule(in.string()));
  343|  4.62k|        } catch (const std::exception& ex) {
  344|     50|          throw tao::pegtl::parse_error(ex.what(), in);
  345|     50|        }
  346|  4.62k|      }
_ZN8usbguard10RuleParser22with_interface_actionsINS0_18str_with_interfaceEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  364|  4.85k|      {
  365|  4.85k|        if (!rule.attributeWithInterface().empty()) {
  ------------------
  |  Branch (365:13): [True: 1, False: 4.85k]
  ------------------
  366|      1|          throw tao::pegtl::parse_error("with-interface attribute already defined", in);
  367|      1|        }
  368|  4.85k|      }
_ZN8usbguard10RuleParser22with_interface_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  385|  3.23k|      {
  386|  3.23k|        try {
  387|  3.23k|          rule.attributeWithInterface().setSetOperator(Rule::setOperatorFromString(in.string()));
  388|  3.23k|        } catch (const std::exception& ex) {
  389|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  390|      0|        }
  391|  3.23k|      }
_ZN8usbguard10RuleParser22with_interface_actionsINS0_15interface_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  373|   180k|      {
  374|   180k|        try {
  375|   180k|          const USBInterfaceType interface_type(in.string());
  376|   180k|          rule.attributeWithInterface().append(interface_type);
  377|   180k|        } catch (const std::exception& ex) {
  378|      8|          throw tao::pegtl::parse_error(ex.what(), in);
  379|      8|        }
  380|   180k|      }
_ZN8usbguard10RuleParser25with_connect_type_actionsINS0_21str_with_connect_typeEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  298|  4.31k|      {
  299|  4.31k|        if (!rule.attributeWithConnectType().empty()) {
  ------------------
  |  Branch (299:13): [True: 3, False: 4.31k]
  ------------------
  300|      3|          throw tao::pegtl::parse_error("with-connect-type attribute already defined", in);
  301|      3|        }
  302|  4.31k|      }
_ZN8usbguard10RuleParser25with_connect_type_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  318|  1.38k|      {
  319|  1.38k|        try {
  320|  1.38k|          rule.attributeWithConnectType().setSetOperator(Rule::setOperatorFromString(in.string()));
  321|  1.38k|        } catch (const std::exception& ex) {
  322|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  323|      0|        }
  324|  1.38k|      }
_ZN8usbguard10RuleParser25with_connect_type_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  307|  9.01k|      {
  308|  9.01k|        try {
  309|  9.01k|          rule.attributeWithConnectType().append(stringValueFromRule(in.string()));
  310|  9.01k|        } catch (const std::exception& ex) {
  311|     45|          throw tao::pegtl::parse_error(ex.what(), in);
  312|     45|        }
  313|  9.01k|      }
_ZN8usbguard10RuleParser17condition_actionsINS0_6str_ifEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  398|  7.35k|      {
  399|  7.35k|        if (!rule.attributeConditions().empty()) {
  ------------------
  |  Branch (399:13): [True: 6, False: 7.34k]
  ------------------
  400|      6|          throw tao::pegtl::parse_error("conditions already defined", in);
  401|      6|        }
  402|  7.35k|      }
_ZN8usbguard10RuleParser17condition_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  418|  2.15k|      {
  419|  2.15k|        try {
  420|  2.15k|          rule.attributeConditions().setSetOperator(Rule::setOperatorFromString(in.string()));
  421|  2.15k|        } catch (const std::exception& ex) {
  422|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  423|      0|        }
  424|  2.15k|      }
_ZN8usbguard10RuleParser17condition_actionsINS0_9conditionEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  407|   633k|      {
  408|   633k|        try {
  409|   633k|          rule.attributeConditions().append(RuleCondition(in.string()));
  410|   633k|        } catch (const std::exception& ex) {
  411|  1.79k|          throw tao::pegtl::parse_error(ex.what(), in);
  412|  1.79k|        }
  413|   633k|      }
_ZN8usbguard10RuleParser13label_actionsINS0_17multiset_operatorEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  285|  1.44k|      {
  286|  1.44k|        try {
  287|  1.44k|          rule.attributeLabel().setSetOperator(Rule::setOperatorFromString(in.string()));
  288|  1.44k|        } catch (const std::exception& ex) {
  289|      0|          throw tao::pegtl::parse_error(ex.what(), in);
  290|      0|        }
  291|  1.44k|      }
_ZN8usbguard10RuleParser13label_actionsINS0_12string_valueEE5applyIN3tao5pegtl8internal12action_inputINS6_12memory_inputILNS6_13tracking_modeE0ENS6_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEEEEEvRKT_RNS_4RuleE:
  274|  5.61k|      {
  275|  5.61k|        try {
  276|  5.61k|          rule.attributeLabel().append(stringValueFromRule(in.string()));
  277|  5.61k|        } catch (const std::exception& ex) {
  278|     32|          throw tao::pegtl::parse_error(ex.what(), in);
  279|     32|        }
  280|  5.61k|      }

_ZN8usbguard11RulePrivateC2Ev:
   33|   138k|    : _device_id("id"),
   34|   138k|      _serial("serial"),
   35|   138k|      _with_connect_type("with-connect-type"),
   36|   138k|      _name("name"),
   37|   138k|      _hash("hash"),
   38|   138k|      _parent_hash("parent-hash"),
   39|   138k|      _via_port("via-port"),
   40|   138k|      _with_interface("with-interface"),
   41|   138k|      _conditions("if"),
   42|   138k|      _label("label")
   43|   138k|  {
   44|   138k|    _rule_id = Rule::DefaultID;
   45|   138k|    _target = Rule::Target::Invalid;
   46|   138k|    _conditions_state = 0;
   47|   138k|  }
_ZN8usbguard11RulePrivateC2ERKS0_:
   50|  91.1k|    : _device_id("id"),
   51|  91.1k|      _serial("serial"),
   52|  91.1k|      _with_connect_type("with-connect-type"),
   53|  91.1k|      _name("name"),
   54|  91.1k|      _hash("hash"),
   55|  91.1k|      _parent_hash("parent-hash"),
   56|  91.1k|      _via_port("via-port"),
   57|  91.1k|      _with_interface("with-interface"),
   58|  91.1k|      _conditions("if"),
   59|  91.1k|      _label("label")
   60|  91.1k|  {
   61|  91.1k|    *this = rhs;
   62|  91.1k|  }
_ZN8usbguard11RulePrivate9setTargetENS_4Rule6TargetE:
  219|  46.8k|  {
  220|  46.8k|    _target = target;
  221|  46.8k|  }
_ZNK8usbguard11RulePrivate9getTargetEv:
  224|  16.4k|  {
  225|  16.4k|    return _target;
  226|  16.4k|  }
_ZN8usbguard11RulePrivate11setDeviceIDERKNS_11USBDeviceIDE:
  229|  3.63k|  {
  230|  3.63k|    _device_id.set(device_id);
  231|  3.63k|  }
_ZN8usbguard11RulePrivate17attributeDeviceIDEv:
  244|   817k|  {
  245|   817k|    return _device_id;
  246|   817k|  }
_ZN8usbguard11RulePrivate15attributeSerialEv:
  264|  10.2k|  {
  265|  10.2k|    return _serial;
  266|  10.2k|  }
_ZN8usbguard11RulePrivate14attributeLabelEv:
  284|  7.06k|  {
  285|  7.06k|    return _label;
  286|  7.06k|  }
_ZN8usbguard11RulePrivate24attributeWithConnectTypeEv:
  304|  14.7k|  {
  305|  14.7k|    return _with_connect_type;
  306|  14.7k|  }
_ZN8usbguard11RulePrivate13attributeNameEv:
  324|   355k|  {
  325|   355k|    return _name;
  326|   355k|  }
_ZN8usbguard11RulePrivate13attributeHashEv:
  344|  39.9k|  {
  345|  39.9k|    return _hash;
  346|  39.9k|  }
_ZN8usbguard11RulePrivate19attributeParentHashEv:
  364|  9.10k|  {
  365|  9.10k|    return _parent_hash;
  366|  9.10k|  }
_ZN8usbguard11RulePrivate16attributeViaPortEv:
  384|  8.89k|  {
  385|  8.89k|    return _via_port;
  386|  8.89k|  }
_ZN8usbguard11RulePrivate22attributeWithInterfaceEv:
  394|   188k|  {
  395|   188k|    return _with_interface;
  396|   188k|  }
_ZN8usbguard11RulePrivate19attributeConditionsEv:
  404|   643k|  {
  405|   643k|    return _conditions;
  406|   643k|  }

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

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

_ZN8usbguard9ExceptionC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_S9_:
   43|    210|      : _context(context),
   44|    210|        _object(object),
   45|    210|        _reason(reason_val)
   46|    210|    {
   47|    210|    }
_ZNK8usbguard9Exception4whatEv:
  102|    210|    {
  103|    210|      return "usbguard::Exception";
  104|    210|    }

_ZN8usbguard7LogSinkC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  100|      2|    : _name(name)
  101|      2|  {
  102|      2|  }
_ZNK8usbguard7LogSink4nameEv:
  109|      2|  {
  110|      2|    return _name;
  111|      2|  }
_ZN8usbguard6LoggerC2Ev:
  279|      2|    : _enabled(true),
  280|      2|      _level(LogStream::Level::Warning)
  281|      2|  {
  282|      2|    const char* const envval = getenv("USBGUARD_DEBUG");
  283|       |
  284|       |    /*
  285|       |     * If USBGUARD_DEBUG=1 is set in the current environment,
  286|       |     * set the debugging level to the highest level.
  287|       |     */
  288|      2|    if (envval != nullptr && strcmp(envval, "1") == 0) {
  ------------------
  |  Branch (288:9): [True: 0, False: 2]
  |  Branch (288:30): [True: 0, False: 0]
  ------------------
  289|      0|      _level = LogStream::Level::Trace;
  290|      0|    }
  291|       |
  292|      2|    setOutputConsole(true);
  293|      2|  }
_ZNK8usbguard6Logger4lockEv:
  300|  9.24k|  {
  301|  9.24k|    return std::unique_lock<std::mutex>(_mutex);
  302|  9.24k|  }
_ZNK8usbguard6Logger9isEnabledENS_9LogStream5LevelE:
  312|  9.24k|  {
  313|  9.24k|    auto L = lock();
  314|  9.24k|    return (_enabled && _level >= level);
  ------------------
  |  Branch (314:13): [True: 9.24k, False: 0]
  |  Branch (314:25): [True: 0, False: 9.24k]
  ------------------
  315|  9.24k|  }
_ZN8usbguard6Logger16setOutputConsoleEb:
  318|      2|  {
  319|      2|    auto L = lock();
  320|       |
  321|      2|    if (state == true) {
  ------------------
  |  Branch (321:9): [True: 2, False: 0]
  ------------------
  322|      2|      std::unique_ptr<LogSink> sink(new ConsoleSink);
  323|      2|      addOutputSink_nolock(sink);
  324|      2|    }
  325|      0|    else {
  326|      0|      delOutputSink_nolock("console");
  327|      0|    }
  328|      2|  }
_ZN8usbguard6Logger20addOutputSink_nolockERNSt3__110unique_ptrINS_7LogSinkENS1_14default_deleteIS3_EEEE:
  376|      2|  {
  377|      2|    _sinks.emplace(sink->name(), std::move(sink));
  378|      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:
   41|   138k|    : d_pointer(usbguard::make_unique<RulePrivate>())
   42|   138k|  {
   43|   138k|  }
_ZN8usbguard4RuleD2Ev:
   45|   138k|  Rule::~Rule() = default;
_ZN8usbguard4RuleaSERKS0_:
   53|  91.1k|  {
   54|  91.1k|    d_pointer.reset(new RulePrivate(*rhs.d_pointer));
   55|  91.1k|    return *this;
   56|  91.1k|  }
_ZN8usbguard4Rule9setTargetENS0_6TargetE:
   69|  46.8k|  {
   70|  46.8k|    d_pointer->setTarget(target);
   71|  46.8k|  }
_ZNK8usbguard4Rule9getTargetEv:
   74|  16.4k|  {
   75|  16.4k|    return d_pointer->getTarget();
   76|  16.4k|  }
_ZN8usbguard4Rule11setDeviceIDERKNS_11USBDeviceIDE:
   79|  3.63k|  {
   80|  3.63k|    d_pointer->setDeviceID(value);
   81|  3.63k|  }
_ZN8usbguard4Rule17attributeDeviceIDEv:
   94|   817k|  {
   95|   817k|    return d_pointer->attributeDeviceID();
   96|   817k|  }
_ZN8usbguard4Rule15attributeSerialEv:
  114|  10.2k|  {
  115|  10.2k|    return d_pointer->attributeSerial();
  116|  10.2k|  }
_ZN8usbguard4Rule14attributeLabelEv:
  134|  7.06k|  {
  135|  7.06k|    return d_pointer->attributeLabel();
  136|  7.06k|  }
_ZN8usbguard4Rule24attributeWithConnectTypeEv:
  154|  14.7k|  {
  155|  14.7k|    return d_pointer->attributeWithConnectType();
  156|  14.7k|  }
_ZN8usbguard4Rule13attributeNameEv:
  174|   355k|  {
  175|   355k|    return d_pointer->attributeName();
  176|   355k|  }
_ZN8usbguard4Rule13attributeHashEv:
  194|  39.9k|  {
  195|  39.9k|    return d_pointer->attributeHash();
  196|  39.9k|  }
_ZN8usbguard4Rule19attributeParentHashEv:
  214|  9.10k|  {
  215|  9.10k|    return d_pointer->attributeParentHash();
  216|  9.10k|  }
_ZN8usbguard4Rule16attributeViaPortEv:
  234|  8.89k|  {
  235|  8.89k|    return d_pointer->attributeViaPort();
  236|  8.89k|  }
_ZN8usbguard4Rule22attributeWithInterfaceEv:
  244|   188k|  {
  245|   188k|    return d_pointer->attributeWithInterface();
  246|   188k|  }
_ZN8usbguard4Rule19attributeConditionsEv:
  254|   643k|  {
  255|   643k|    return d_pointer->attributeConditions();
  256|   643k|  }
_ZN8usbguard4Rule16targetFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  328|  46.8k|  {
  329|  51.7k|    for (auto ttable_entry : target_ttable) {
  ------------------
  |  Branch (329:28): [True: 51.7k, False: 0]
  ------------------
  330|  51.7k|      if (ttable_entry.first == target_string) {
  ------------------
  |  Branch (330:11): [True: 46.8k, False: 4.91k]
  ------------------
  331|  46.8k|        return ttable_entry.second;
  332|  46.8k|      }
  333|  51.7k|    }
  334|       |
  335|      0|    throw std::runtime_error("Invalid rule target string");
  336|  46.8k|  }
_ZN8usbguard4Rule21setOperatorFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  381|  19.5k|  {
  382|  70.5k|    for (auto ttable_entry : set_operator_ttable) {
  ------------------
  |  Branch (382:28): [True: 70.5k, False: 0]
  ------------------
  383|  70.5k|      if (ttable_entry.first == set_operator_string) {
  ------------------
  |  Branch (383:11): [True: 19.5k, False: 50.9k]
  ------------------
  384|  19.5k|        return ttable_entry.second;
  385|  19.5k|      }
  386|  70.5k|    }
  387|       |
  388|      0|    throw std::runtime_error("Invalid set operator string");
  389|  19.5k|  }

_ZNK8usbguard4Rule9AttributeINS_11USBDeviceIDEE5emptyEv:
  296|  3.59k|      {
  297|  3.59k|        return count() == 0;
  298|  3.59k|      }
_ZNK8usbguard4Rule9AttributeINS_11USBDeviceIDEE5countEv:
  285|  10.8k|      {
  286|  10.8k|        return _values.size();
  287|  10.8k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE14setSetOperatorENS0_11SetOperatorE:
  245|  1.74k|      {
  246|  1.74k|        _set_operator = op;
  247|  1.74k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE6appendERKS2_:
  275|   815k|      {
  276|   815k|        _values.push_back(value);
  277|   815k|      }
_ZNK8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5emptyEv:
  296|  23.9k|      {
  297|  23.9k|        return count() == 0;
  298|  23.9k|      }
_ZNK8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5countEv:
  285|  23.9k|      {
  286|  23.9k|        return _values.size();
  287|  23.9k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE14setSetOperatorENS0_11SetOperatorE:
  245|  12.4k|      {
  246|  12.4k|        _set_operator = op;
  247|  12.4k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE6appendERKS8_:
  275|   408k|      {
  276|   408k|        _values.push_back(value);
  277|   408k|      }
_ZNK8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE5emptyEv:
  296|  4.85k|      {
  297|  4.85k|        return count() == 0;
  298|  4.85k|      }
_ZNK8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE5countEv:
  285|  4.85k|      {
  286|  4.85k|        return _values.size();
  287|  4.85k|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE14setSetOperatorENS0_11SetOperatorE:
  245|  3.23k|      {
  246|  3.23k|        _set_operator = op;
  247|  3.23k|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEE6appendERKS2_:
  275|   180k|      {
  276|   180k|        _values.push_back(value);
  277|   180k|      }
_ZNK8usbguard4Rule9AttributeINS_13RuleConditionEE5emptyEv:
  296|  7.35k|      {
  297|  7.35k|        return count() == 0;
  298|  7.35k|      }
_ZNK8usbguard4Rule9AttributeINS_13RuleConditionEE5countEv:
  285|  7.35k|      {
  286|  7.35k|        return _values.size();
  287|  7.35k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEE14setSetOperatorENS0_11SetOperatorE:
  245|  2.15k|      {
  246|  2.15k|        _set_operator = op;
  247|  2.15k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEE6appendEOS2_:
  265|   631k|      {
  266|   631k|        _values.emplace_back(std::move(value));
  267|   631k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEEaSERKS3_:
  237|  91.1k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEaSERKS9_:
  237|   638k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEEaSERKS3_:
  237|  91.1k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEEaSERKS3_:
  237|  91.1k|      Attribute& operator=(const Attribute<ValueType>& rhs) = default;
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEEC2EPKc:
  220|   230k|      {
  221|   230k|        _name = name;
  222|   230k|        _set_operator = SetOperator::Equals;
  223|   230k|      }
_ZN8usbguard4Rule9AttributeINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPKc:
  220|  1.61M|      {
  221|  1.61M|        _name = name;
  222|  1.61M|        _set_operator = SetOperator::Equals;
  223|  1.61M|      }
_ZN8usbguard4Rule9AttributeINS_16USBInterfaceTypeEEC2EPKc:
  220|   230k|      {
  221|   230k|        _name = name;
  222|   230k|        _set_operator = SetOperator::Equals;
  223|   230k|      }
_ZN8usbguard4Rule9AttributeINS_13RuleConditionEEC2EPKc:
  220|   230k|      {
  221|   230k|        _name = name;
  222|   230k|        _set_operator = SetOperator::Equals;
  223|   230k|      }
_ZN8usbguard4Rule9AttributeINS_11USBDeviceIDEE3setERKS2_:
  380|  3.63k|      {
  381|  3.63k|        if (count() > 1) {
  ------------------
  |  Branch (381:13): [True: 0, False: 3.63k]
  ------------------
  382|      0|          throw std::runtime_error("BUG: Setting single value for a multivalued attribute");
  383|      0|        }
  384|       |
  385|  3.63k|        if (count() == 0) {
  ------------------
  |  Branch (385:13): [True: 3.63k, False: 0]
  ------------------
  386|  3.63k|          append(value);
  387|  3.63k|        }
  388|      0|        else {
  389|      0|          _values[0] = value;
  390|      0|        }
  391|  3.63k|      }

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

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

_ZN8usbguard15RuleParserErrorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_S9_mj:
   48|  8.60k|      : _rule_spec(rule_spec),
   49|  8.60k|        _hint(hint),
   50|  8.60k|        _offset(error_offset),
   51|  8.60k|        _file(file),
   52|  8.60k|        _line(error_line)
   53|  8.60k|    {
   54|  8.60k|    }
_ZN8usbguard15RuleParserError7setHintERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   62|  8.60k|    {
   63|  8.60k|      _hint = hint;
   64|  8.60k|    }
_ZN8usbguard15RuleParserError9setOffsetEm:
   72|  8.60k|    {
   73|  8.60k|      _offset = offset;
   74|  8.60k|    }
_ZN8usbguard15RuleParserError11setFileInfoERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmm:
   84|  7.71k|    {
   85|  7.71k|      _file = file;
   86|  7.71k|      _line = error_line;
   87|  7.71k|      _offset = error_offset;
   88|  7.71k|    }
_ZNK8usbguard15RuleParserError4whatEv:
   96|    885|    {
   97|    885|      return "RuleParserError";
   98|    885|    }

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

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

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

_ZN3tao5pegtl8demangleINS0_3repILj2EJNS0_5ascii6xdigitEEEEEENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEv:
   35|    249|{
   36|    249|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    249|   constexpr auto begin = sv.find( '=' );
   38|    249|   static_assert( begin != std::string_view::npos );
   39|    249|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    249|}
_ZN3tao5pegtl8demangleINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEENSt3__117basic_string_viewIcNSC_11char_traitsIcEEEEv:
   35|    348|{
   36|    348|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    348|   constexpr auto begin = sv.find( '=' );
   38|    348|   static_assert( begin != std::string_view::npos );
   39|    348|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    348|}
_ZN3tao5pegtl8demangleINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEv:
   35|  1.20k|{
   36|  1.20k|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|  1.20k|   constexpr auto begin = sv.find( '=' );
   38|  1.20k|   static_assert( begin != std::string_view::npos );
   39|  1.20k|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|  1.20k|}
_ZN3tao5pegtl8demangleINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEEENSt3__117basic_string_viewIcNSC_11char_traitsIcEEEEv:
   35|     75|{
   36|     75|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|     75|   constexpr auto begin = sv.find( '=' );
   38|     75|   static_assert( begin != std::string_view::npos );
   39|     75|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|     75|}
_ZN3tao5pegtl8demangleINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEv:
   35|    277|{
   36|    277|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|    277|   constexpr auto begin = sv.find( '=' );
   38|    277|   static_assert( begin != std::string_view::npos );
   39|    277|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|    277|}
_ZN3tao5pegtl8demangleINS0_3eofEEENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEv:
   35|  4.27k|{
   36|  4.27k|   constexpr std::string_view sv = __PRETTY_FUNCTION__;
   37|  4.27k|   constexpr auto begin = sv.find( '=' );
   38|  4.27k|   static_assert( begin != std::string_view::npos );
   39|  4.27k|   return sv.substr( begin + 2, sv.size() - begin - 3 );
   40|  4.27k|}

_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|  50.3k|      {
   45|  50.3k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  50.3k|      }
_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|  47.1k|      {
   45|  47.1k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  47.1k|      }
_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|  43.4k|      {
   45|  43.4k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  43.4k|      }
_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|  37.7k|      {
   45|  37.7k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  37.7k|      }
_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|  35.0k|      {
   45|  35.0k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  35.0k|      }
_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|  31.8k|      {
   45|  31.8k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  31.8k|      }
_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|  29.1k|      {
   45|  29.1k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  29.1k|      }
_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|  24.6k|      {
   45|  24.6k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  24.6k|      }
_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|  20.6k|      {
   45|  20.6k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  20.6k|      }
_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|  13.9k|      {
   45|  13.9k|         return Control< Rule >::template match< A, M, Action, Control >( in, st... );
   46|  13.9k|      }

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

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

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

_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.85M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.85M|      else {
   20|  3.85M|         in.bump_in_this_line( count );
   21|  3.85M|      }
   22|  3.85M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  16.4k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  16.4k|      else {
   20|  16.4k|         in.bump_in_this_line( count );
   21|  16.4k|      }
   22|  16.4k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc97ELc108ELc108ELc111ELc119EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  43.4k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  43.4k|      else {
   20|  43.4k|         in.bump_in_this_line( count );
   21|  43.4k|      }
   22|  43.4k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc98ELc108ELc111ELc99ELc107EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.60k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.60k|      else {
   20|  2.60k|         in.bump_in_this_line( count );
   21|  2.60k|      }
   22|  2.60k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc114ELc101ELc106ELc101ELc99ELc116EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|     11|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|     11|      else {
   20|     11|         in.bump_in_this_line( count );
   21|     11|      }
   22|     11|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc109ELc97ELc116ELc99ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|    711|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|    711|      else {
   20|    711|         in.bump_in_this_line( count );
   21|    711|      }
   22|    711|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc100ELc101ELc118ELc105ELc99ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|     39|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|     39|      else {
   20|     39|         in.bump_in_this_line( count );
   21|     39|      }
   22|     39|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_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_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.79M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.79M|      else {
   20|  1.79M|         in.bump_in_this_line( count );
   21|  1.79M|      }
   22|  1.79M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  1.17M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  1.17M|      else {
   20|  1.17M|         in.bump_in_this_line( count );
   21|  1.17M|      }
   22|  1.17M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc105ELc100EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.59k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.59k|      else {
   20|  3.59k|         in.bump_in_this_line( count );
   21|  3.59k|      }
   22|  3.59k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc97ELc108ELc108ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.81k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.81k|      else {
   20|  2.81k|         in.bump_in_this_line( count );
   21|  2.81k|      }
   22|  2.81k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc111ELc110ELc101ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.47k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.47k|      else {
   20|  4.47k|         in.bump_in_this_line( count );
   21|  4.47k|      }
   22|  4.47k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc110ELc111ELc110ELc101ELc45ELc111ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.89k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.89k|      else {
   20|  2.89k|         in.bump_in_this_line( count );
   21|  2.89k|      }
   22|  2.89k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc101ELc113ELc117ELc97ELc108ELc115ELc45ELc111ELc114ELc100ELc101ELc114ELc101ELc100EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.51k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.51k|      else {
   20|  3.51k|         in.bump_in_this_line( count );
   21|  3.51k|      }
   22|  3.51k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc101ELc113ELc117ELc97ELc108ELc115EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.93k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.93k|      else {
   20|  2.93k|         in.bump_in_this_line( count );
   21|  2.93k|      }
   22|  2.93k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc109ELc97ELc116ELc99ELc104ELc45ELc97ELc108ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.96k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.96k|      else {
   20|  2.96k|         in.bump_in_this_line( count );
   21|  2.96k|      }
   22|  2.96k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  30.5k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  30.5k|      else {
   20|  30.5k|         in.bump_in_this_line( count );
   21|  30.5k|      }
   22|  30.5k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  26.9k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  26.9k|      else {
   20|  26.9k|         in.bump_in_this_line( count );
   21|  26.9k|      }
   22|  26.9k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc110ELc97ELc109ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.06k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.06k|      else {
   20|  4.06k|         in.bump_in_this_line( count );
   21|  4.06k|      }
   22|  4.06k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   826k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   826k|      else {
   20|   826k|         in.bump_in_this_line( count );
   21|   826k|      }
   22|   826k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   773k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   773k|      else {
   20|   773k|         in.bump_in_this_line( count );
   21|   773k|      }
   22|   773k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   259k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   259k|      else {
   20|   259k|         in.bump_in_this_line( count );
   21|   259k|      }
   22|   259k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_5rangeILNS1_15result_on_foundE1ENS1_9peek_charELc48ELc57EEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   251k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   251k|      else {
   20|   251k|         in.bump_in_this_line( count );
   21|   251k|      }
   22|   251k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   315k|   {
   16|   315k|      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|   315k|         in.bump( count );
   18|       |      }
   19|       |      else {
   20|       |         in.bump_in_this_line( count );
   21|       |      }
   22|   315k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|   111M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   111M|      else {
   20|   111M|         in.bump_in_this_line( count );
   21|   111M|      }
   22|   111M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc104ELc97ELc115ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  6.07k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  6.07k|      else {
   20|  6.07k|         in.bump_in_this_line( count );
   21|  6.07k|      }
   22|  6.07k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc112ELc97ELc114ELc101ELc110ELc116ELc45ELc104ELc97ELc115ELc104EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  2.99k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  2.99k|      else {
   20|  2.99k|         in.bump_in_this_line( count );
   21|  2.99k|      }
   22|  2.99k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc115ELc101ELc114ELc105ELc97ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.44k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.44k|      else {
   20|  3.44k|         in.bump_in_this_line( count );
   21|  3.44k|      }
   22|  3.44k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc118ELc105ELc97ELc45ELc112ELc111ELc114ELc116EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  3.04k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  3.04k|      else {
   20|  3.04k|         in.bump_in_this_line( count );
   21|  3.04k|      }
   22|  3.04k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc119ELc105ELc116ELc104ELc45ELc105ELc110ELc116ELc101ELc114ELc102ELc97ELc99ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.85k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.85k|      else {
   20|  4.85k|         in.bump_in_this_line( count );
   21|  4.85k|      }
   22|  4.85k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc119ELc105ELc116ELc104ELc45ELc99ELc111ELc110ELc110ELc101ELc99ELc116ELc45ELc116ELc121ELc112ELc101EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.31k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.31k|      else {
   20|  4.31k|         in.bump_in_this_line( count );
   21|  4.31k|      }
   22|  4.31k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc105ELc102EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  7.35k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  7.35k|      else {
   20|  7.35k|         in.bump_in_this_line( count );
   21|  7.35k|      }
   22|  7.35k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|    347|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|    347|      else {
   20|    347|         in.bump_in_this_line( count );
   21|    347|      }
   22|    347|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|   634k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|   634k|      else {
   20|   634k|         in.bump_in_this_line( count );
   21|   634k|      }
   22|   634k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEvRT0_m:
   15|  24.9M|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  24.9M|      else {
   20|  24.9M|         in.bump_in_this_line( count );
   21|  24.9M|      }
   22|  24.9M|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  48.7k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  48.7k|      else {
   20|  48.7k|         in.bump_in_this_line( count );
   21|  48.7k|      }
   22|  48.7k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEvRT0_m:
   15|  48.5k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  48.5k|      else {
   20|  48.5k|         in.bump_in_this_line( count );
   21|  48.5k|      }
   22|  48.5k|   }
_ZN3tao5pegtl8internal9bump_helpINS1_6stringIJLc108ELc97ELc98ELc101ELc108EEEENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEvRT0_m:
   15|  4.09k|   {
   16|       |      if constexpr( Rule::template can_match_eol< ParseInput::eol_t::ch > ) {
   17|       |         in.bump( count );
   18|       |      }
   19|  4.09k|      else {
   20|  4.09k|         in.bump_in_this_line( count );
   21|  4.09k|      }
   22|  4.09k|   }

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

_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|  89.4k|      {
   38|  89.4k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 16.4k, False: 72.9k]
  ------------------
   39|  16.4k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  16.4k|            return true;
   41|  16.4k|         }
   42|  72.9k|         return Default;
   43|  89.4k|      }
_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|   350k|      {
   38|   350k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 349k, False: 1.15k]
  ------------------
   39|   349k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   349k|            return true;
   41|   349k|         }
   42|  1.15k|         return Default;
   43|   350k|      }
_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|  13.2M|      {
   38|  13.2M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 192k, False: 13.0M]
  ------------------
   39|   192k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   192k|            return true;
   41|   192k|         }
   42|  13.0M|         return Default;
   43|  13.2M|      }
_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|   192k|      {
   38|   192k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 83.6k, False: 108k]
  ------------------
   39|  83.6k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  83.6k|            return true;
   41|  83.6k|         }
   42|   108k|         return Default;
   43|   192k|      }
_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|   108k|      {
   38|   108k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 33.5k, False: 75.0k]
  ------------------
   39|  33.5k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  33.5k|            return true;
   41|  33.5k|         }
   42|  75.0k|         return Default;
   43|   108k|      }
_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|  31.6k|      {
   38|  31.6k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 30.5k, False: 1.06k]
  ------------------
   39|  30.5k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  30.5k|            return true;
   41|  30.5k|         }
   42|  1.06k|         return Default;
   43|  31.6k|      }
_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|  13.4M|      {
   38|  13.4M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 70.6k, False: 13.3M]
  ------------------
   39|  70.6k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  70.6k|            return true;
   41|  70.6k|         }
   42|  13.3M|         return Default;
   43|  13.4M|      }
_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|  70.6k|      {
   38|  70.6k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 18.2k, False: 52.4k]
  ------------------
   39|  18.2k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  18.2k|            return true;
   41|  18.2k|         }
   42|  52.4k|         return Default;
   43|  70.6k|      }
_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|  52.4k|      {
   38|  52.4k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 27.0k, False: 25.3k]
  ------------------
   39|  27.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  27.0k|            return true;
   41|  27.0k|         }
   42|  25.3k|         return Default;
   43|  52.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|  5.80k|      {
   38|  5.80k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.10k, False: 704]
  ------------------
   39|  5.10k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.10k|            return true;
   41|  5.10k|         }
   42|    704|         return Default;
   43|  5.80k|      }
_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|  5.88M|      {
   38|  5.88M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 100k, False: 5.78M]
  ------------------
   39|   100k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   100k|            return true;
   41|   100k|         }
   42|  5.78M|         return Default;
   43|  5.88M|      }
_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|   100k|      {
   38|   100k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 36.0k, False: 64.4k]
  ------------------
   39|  36.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  36.0k|            return true;
   41|  36.0k|         }
   42|  64.4k|         return Default;
   43|   100k|      }
_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|  64.4k|      {
   38|  64.4k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 22.0k, False: 42.3k]
  ------------------
   39|  22.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  22.0k|            return true;
   41|  22.0k|         }
   42|  42.3k|         return Default;
   43|  64.4k|      }
_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|  6.16k|      {
   38|  6.16k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.59k, False: 568]
  ------------------
   39|  5.59k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.59k|            return true;
   41|  5.59k|         }
   42|    568|         return Default;
   43|  6.16k|      }
_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.87M|      {
   38|  2.87M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 22.0k, False: 2.85M]
  ------------------
   39|  22.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  22.0k|            return true;
   41|  22.0k|         }
   42|  2.85M|         return Default;
   43|  2.87M|      }
_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|  22.0k|      {
   38|  22.0k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.82k, False: 16.2k]
  ------------------
   39|  5.82k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.82k|            return true;
   41|  5.82k|         }
   42|  16.2k|         return Default;
   43|  22.0k|      }
_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|  16.2k|      {
   38|  16.2k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 8.13k, False: 8.07k]
  ------------------
   39|  8.13k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  8.13k|            return true;
   41|  8.13k|         }
   42|  8.07k|         return Default;
   43|  16.2k|      }
_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|  5.85k|      {
   38|  5.85k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 4.87k, False: 980]
  ------------------
   39|  4.87k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  4.87k|            return true;
   41|  4.87k|         }
   42|    980|         return Default;
   43|  5.85k|      }
_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.76M|      {
   38|  6.76M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 45.4k, False: 6.72M]
  ------------------
   39|  45.4k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  45.4k|            return true;
   41|  45.4k|         }
   42|  6.72M|         return Default;
   43|  6.76M|      }
_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|  45.4k|      {
   38|  45.4k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 19.7k, False: 25.7k]
  ------------------
   39|  19.7k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  19.7k|            return true;
   41|  19.7k|         }
   42|  25.7k|         return Default;
   43|  45.4k|      }
_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|  25.7k|      {
   38|  25.7k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 10.1k, False: 15.5k]
  ------------------
   39|  10.1k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  10.1k|            return true;
   41|  10.1k|         }
   42|  15.5k|         return Default;
   43|  25.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|  10.0k|      {
   38|  10.0k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 9.26k, False: 772]
  ------------------
   39|  9.26k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  9.26k|            return true;
   41|  9.26k|         }
   42|    772|         return Default;
   43|  10.0k|      }
_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|  9.70M|      {
   38|  9.70M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 99.3k, False: 9.60M]
  ------------------
   39|  99.3k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  99.3k|            return true;
   41|  99.3k|         }
   42|  9.60M|         return Default;
   43|  9.70M|      }
_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|  99.3k|      {
   38|  99.3k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 25.8k, False: 73.4k]
  ------------------
   39|  25.8k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  25.8k|            return true;
   41|  25.8k|         }
   42|  73.4k|         return Default;
   43|  99.3k|      }
_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|  73.4k|      {
   38|  73.4k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 30.4k, False: 42.9k]
  ------------------
   39|  30.4k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  30.4k|            return true;
   41|  30.4k|         }
   42|  42.9k|         return Default;
   43|  73.4k|      }
_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|   634k|      {
   38|   634k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 48.7k, False: 585k]
  ------------------
   39|  48.7k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  48.7k|            return true;
   41|  48.7k|         }
   42|   585k|         return Default;
   43|   634k|      }
_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|  50.7M|      {
   38|  50.7M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 146k, False: 50.5M]
  ------------------
   39|   146k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|   146k|            return true;
   41|   146k|         }
   42|  50.5M|         return Default;
   43|  50.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|   146k|      {
   38|   146k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 33.2k, False: 113k]
  ------------------
   39|  33.2k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  33.2k|            return true;
   41|  33.2k|         }
   42|   113k|         return Default;
   43|   146k|      }
_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|   113k|      {
   38|   113k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 31.4k, False: 81.9k]
  ------------------
   39|  31.4k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  31.4k|            return true;
   41|  31.4k|         }
   42|  81.9k|         return Default;
   43|   113k|      }
_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|  6.77k|      {
   38|  6.77k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 5.89k, False: 885]
  ------------------
   39|  5.89k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  5.89k|            return true;
   41|  5.89k|         }
   42|    885|         return Default;
   43|  6.77k|      }
_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|  9.38M|      {
   38|  9.38M|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 97.0k, False: 9.28M]
  ------------------
   39|  97.0k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  97.0k|            return true;
   41|  97.0k|         }
   42|  9.28M|         return Default;
   43|  9.38M|      }
_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|  97.0k|      {
   38|  97.0k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 37.2k, False: 59.8k]
  ------------------
   39|  37.2k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  37.2k|            return true;
   41|  37.2k|         }
   42|  59.8k|         return Default;
   43|  97.0k|      }
_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|  59.8k|      {
   38|  59.8k|         if( Control< Cond >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (38:14): [True: 27.3k, False: 32.4k]
  ------------------
   39|  27.3k|            (void)Control< must< Rules... > >::template match< A, M, Action, Control >( in, st... );
   40|  27.3k|            return true;
   41|  27.3k|         }
   42|  32.4k|         return Default;
   43|  59.8k|      }

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

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

_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE2EEC2ERKS3_:
   19|   624M|      {}
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EEC2ERS3_:
   42|  10.7M|         : m_saved( i ),
   43|  10.7M|           m_input( &i )
   44|  10.7M|      {}
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EEclEb:
   60|  7.13M|      {
   61|  7.13M|         if( result ) {
  ------------------
  |  Branch (61:14): [True: 6.25M, False: 885k]
  ------------------
   62|  6.25M|            m_input = nullptr;
   63|  6.25M|            return true;
   64|  6.25M|         }
   65|   885k|         return false;
   66|  7.13M|      }
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EE8iteratorEv:
   69|  2.14M|      {
   70|  2.14M|         return m_saved;
   71|  2.14M|      }
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE0EEC2ERKS3_:
   19|  2.58M|      {}
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE0EEclEb:
   30|  2.57M|      {
   31|  2.57M|         return result;
   32|  2.57M|      }
_ZN3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE1EED2Ev:
   50|  10.7M|      {
   51|  10.7M|         if( m_input != nullptr ) {
  ------------------
  |  Branch (51:14): [True: 4.47M, False: 6.25M]
  ------------------
   52|  4.47M|            ( *m_input ) = m_saved;
   53|  4.47M|         }
   54|  10.7M|      }
_ZNK3tao5pegtl8internal6markerINS1_8iteratorELNS0_11rewind_modeE2EEclEb:
   30|   624M|      {
   31|   624M|         return result;
   32|   624M|      }

_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|  16.4k|      {
   56|  16.4k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 16.4k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  16.4k|         return true;
   60|  16.4k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|   349k|      {
   56|   349k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 176, False: 348k]
  ------------------
   57|    176|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    176|         }
   59|   349k|         return true;
   60|   349k|      }
_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|   192k|      {
   56|   192k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 65, False: 192k]
  ------------------
   57|     65|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     65|         }
   59|   192k|         return true;
   60|   192k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  83.6k|      {
   56|  83.6k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 21, False: 83.6k]
  ------------------
   57|     21|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     21|         }
   59|  83.6k|         return true;
   60|  83.6k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  33.5k|      {
   56|  33.5k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 33.5k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  33.5k|         return true;
   60|  33.5k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  30.5k|      {
   56|  30.5k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 177, False: 30.3k]
  ------------------
   57|    177|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    177|         }
   59|  30.5k|         return true;
   60|  30.5k|      }
_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|  70.6k|      {
   56|  70.6k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 53, False: 70.5k]
  ------------------
   57|     53|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     53|         }
   59|  70.6k|         return true;
   60|  70.6k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  18.2k|      {
   56|  18.2k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 36, False: 18.1k]
  ------------------
   57|     36|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     36|         }
   59|  18.2k|         return true;
   60|  18.2k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_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: 0, False: 27.0k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  27.0k|         return true;
   60|  27.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|  5.10k|      {
   56|  5.10k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 161, False: 4.94k]
  ------------------
   57|    161|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    161|         }
   59|  5.10k|         return true;
   60|  5.10k|      }
_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|   100k|      {
   56|   100k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 60, False: 100k]
  ------------------
   57|     60|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     60|         }
   59|   100k|         return true;
   60|   100k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  36.0k|      {
   56|  36.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 36, False: 36.0k]
  ------------------
   57|     36|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     36|         }
   59|  36.0k|         return true;
   60|  36.0k|      }
_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|  22.0k|      {
   56|  22.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 22.0k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  22.0k|         return true;
   60|  22.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  5.59k|      {
   56|  5.59k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 165, False: 5.43k]
  ------------------
   57|    165|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    165|         }
   59|  5.59k|         return true;
   60|  5.59k|      }
_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|  22.0k|      {
   56|  22.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 20, False: 22.0k]
  ------------------
   57|     20|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     20|         }
   59|  22.0k|         return true;
   60|  22.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  5.82k|      {
   56|  5.82k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 21, False: 5.80k]
  ------------------
   57|     21|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     21|         }
   59|  5.82k|         return true;
   60|  5.82k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  8.13k|      {
   56|  8.13k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 8.13k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  8.13k|         return true;
   60|  8.13k|      }
_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|  4.87k|      {
   56|  4.87k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 183, False: 4.69k]
  ------------------
   57|    183|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    183|         }
   59|  4.87k|         return true;
   60|  4.87k|      }
_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|  45.4k|      {
   56|  45.4k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 51, False: 45.3k]
  ------------------
   57|     51|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     51|         }
   59|  45.4k|         return true;
   60|  45.4k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  19.7k|      {
   56|  19.7k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 21, False: 19.6k]
  ------------------
   57|     21|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     21|         }
   59|  19.7k|         return true;
   60|  19.7k|      }
_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|  10.1k|      {
   56|  10.1k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 10.1k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  10.1k|         return true;
   60|  10.1k|      }
_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|  9.26k|      {
   56|  9.26k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 177, False: 9.08k]
  ------------------
   57|    177|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    177|         }
   59|  9.26k|         return true;
   60|  9.26k|      }
_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|  99.3k|      {
   56|  99.3k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 35, False: 99.2k]
  ------------------
   57|     35|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     35|         }
   59|  99.3k|         return true;
   60|  99.3k|      }
_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|  25.8k|      {
   56|  25.8k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 33, False: 25.8k]
  ------------------
   57|     33|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     33|         }
   59|  25.8k|         return true;
   60|  25.8k|      }
_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|  30.4k|      {
   56|  30.4k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 30.4k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  30.4k|         return true;
   60|  30.4k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  48.7k|      {
   56|  48.7k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 277, False: 48.4k]
  ------------------
   57|    277|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    277|         }
   59|  48.7k|         return true;
   60|  48.7k|      }
_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|   146k|      {
   56|   146k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 75, False: 146k]
  ------------------
   57|     75|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     75|         }
   59|   146k|         return true;
   60|   146k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  33.2k|      {
   56|  33.2k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 36, False: 33.2k]
  ------------------
   57|     36|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     36|         }
   59|  33.2k|         return true;
   60|  33.2k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  31.4k|      {
   56|  31.4k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 31.4k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  31.4k|         return true;
   60|  31.4k|      }
_ZN3tao5pegtl8internal4mustIJNS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS8_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSM_11char_traitsIcEENSM_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   55|  5.89k|      {
   56|  5.89k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 167, False: 5.72k]
  ------------------
   57|    167|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|    167|         }
   59|  5.89k|         return true;
   60|  5.89k|      }
_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|  97.0k|      {
   56|  97.0k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 64, False: 96.9k]
  ------------------
   57|     64|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     64|         }
   59|  97.0k|         return true;
   60|  97.0k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  37.2k|      {
   56|  37.2k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 45, False: 37.1k]
  ------------------
   57|     45|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|     45|         }
   59|  37.2k|         return true;
   60|  37.2k|      }
_ZN3tao5pegtl8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   55|  27.3k|      {
   56|  27.3k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 0, False: 27.3k]
  ------------------
   57|      0|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|      0|         }
   59|  27.3k|         return true;
   60|  27.3k|      }
_ZN3tao5pegtl8internal4mustIJNS0_3eofEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   55|  42.6k|      {
   56|  42.6k|         if( !Control< Rule >::template match< A, rewind_mode::dontcare, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (56:14): [True: 4.27k, False: 38.3k]
  ------------------
   57|  4.27k|            Control< Rule >::raise( static_cast< const ParseInput& >( in ), st... );
   58|  4.27k|         }
   59|  42.6k|         return true;
   60|  42.6k|      }

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

_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  6.31M|      {
   41|  6.31M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 6.22M, False: 85.8k]
  ------------------
   42|  6.22M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 3.85M, False: 2.36M]
  ------------------
   43|  3.85M|               bump_help< one >( in, t.size );
   44|  3.85M|               return true;
   45|  3.85M|            }
   46|  6.22M|         }
   47|  2.45M|         return false;
   48|  6.31M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc32ELc9EEE4testEc:
   31|  6.22M|      {
   32|  8.66M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 3.78M, False: 2.43M]
  |  Branch (32:19): [True: 70.8k, False: 2.36M]
  ------------------
   33|  6.22M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  89.4k|      {
   41|  89.4k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 67.5k, False: 21.8k]
  ------------------
   42|  67.5k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 16.4k, False: 51.0k]
  ------------------
   43|  16.4k|               bump_help< one >( in, t.size );
   44|  16.4k|               return true;
   45|  16.4k|            }
   46|  67.5k|         }
   47|  72.9k|         return false;
   48|  89.4k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc35EEE4testEc:
   31|  67.5k|      {
   32|  67.5k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  67.5k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  1.84M|      {
   41|  1.84M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 1.83M, False: 854]
  ------------------
   42|  1.83M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.79M, False: 43.7k]
  ------------------
   43|  1.79M|               bump_help< one >( in, t.size );
   44|  1.79M|               return true;
   45|  1.79M|            }
   46|  1.83M|         }
   47|  44.6k|         return false;
   48|  1.84M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc42EEE4testEc:
   31|  1.83M|      {
   32|  1.83M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  1.83M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  1.17M|      {
   41|  1.17M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 1.17M, False: 41]
  ------------------
   42|  1.17M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 1.17M, False: 74]
  ------------------
   43|  1.17M|               bump_help< one >( in, t.size );
   44|  1.17M|               return true;
   45|  1.17M|            }
   46|  1.17M|         }
   47|    115|         return false;
   48|  1.17M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc58EEE4testEc:
   31|  1.17M|      {
   32|  1.17M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  1.17M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  43.6k|      {
   41|  43.6k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 43.2k, False: 395]
  ------------------
   42|  43.2k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 30.5k, False: 12.7k]
  ------------------
   43|  30.5k|               bump_help< one >( in, t.size );
   44|  30.5k|               return true;
   45|  30.5k|            }
   46|  43.2k|         }
   47|  13.0k|         return false;
   48|  43.6k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc123EEE4testEc:
   31|  43.2k|      {
   32|  43.2k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  43.2k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  28.7k|      {
   41|  28.7k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 27.5k, False: 1.11k]
  ------------------
   42|  27.5k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 26.9k, False: 635]
  ------------------
   43|  26.9k|               bump_help< one >( in, t.size );
   44|  26.9k|               return true;
   45|  26.9k|            }
   46|  27.5k|         }
   47|  1.74k|         return false;
   48|  28.7k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc125EEE4testEc:
   31|  27.5k|      {
   32|  27.5k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  27.5k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  62.1M|      {
   41|  62.1M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 62.1M, False: 1.79k]
  ------------------
   42|  62.1M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 826k, False: 61.3M]
  ------------------
   43|   826k|               bump_help< one >( in, t.size );
   44|   826k|               return true;
   45|   826k|            }
   46|  62.1M|         }
   47|  61.3M|         return false;
   48|  62.1M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc34EEE4testEc:
   31|  62.1M|      {
   32|  62.1M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  62.1M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   112M|      {
   41|   112M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 112M, False: 1.44k]
  ------------------
   42|   112M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 773k, False: 111M]
  ------------------
   43|   773k|               bump_help< one >( in, t.size );
   44|   773k|               return true;
   45|   773k|            }
   46|   112M|         }
   47|   111M|         return false;
   48|   112M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc92EEE4testEc:
   31|   112M|      {
   32|   112M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   112M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   773k|      {
   41|   773k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 773k, False: 111]
  ------------------
   42|   773k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 259k, False: 513k]
  ------------------
   43|   259k|               bump_help< one >( in, t.size );
   44|   259k|               return true;
   45|   259k|            }
   46|   773k|         }
   47|   514k|         return false;
   48|   773k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc120EEE4testEc:
   31|   773k|      {
   32|   773k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   773k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   323k|      {
   41|   323k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 323k, False: 111]
  ------------------
   42|   323k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 315k, False: 8.16k]
  ------------------
   43|   315k|               bump_help< one >( in, t.size );
   44|   315k|               return true;
   45|   315k|            }
   46|   323k|         }
   47|  8.27k|         return false;
   48|   323k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc97ELc98ELc102ELc110ELc114ELc116ELc118ELc92ELc39ELc48ELc10EEE4testEc:
   31|   323k|      {
   32|  2.90M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 0, False: 26.4k]
  |  Branch (32:19): [True: 18.2k, False: 8.16k]
  |  Branch (32:19): [True: 18.7k, False: 26.4k]
  |  Branch (32:19): [True: 53.4k, False: 45.2k]
  |  Branch (32:19): [True: 13.5k, False: 98.6k]
  |  Branch (32:19): [True: 18.7k, False: 112k]
  |  Branch (32:19): [True: 29.1k, False: 130k]
  |  Branch (32:19): [True: 22.5k, False: 160k]
  |  Branch (32:19): [True: 46.5k, False: 182k]
  |  Branch (32:19): [True: 61.0k, False: 229k]
  |  Branch (32:19): [True: 33.4k, False: 290k]
  ------------------
   33|   323k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   111M|      {
   41|   111M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 111M, False: 1.44k]
  ------------------
   42|   111M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 111M, False: 40]
  ------------------
   43|   111M|               bump_help< one >( in, t.size );
   44|   111M|               return true;
   45|   111M|            }
   46|   111M|         }
   47|  1.48k|         return false;
   48|   111M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE0ENS1_9peek_charEJLc13ELc10EEE4testEc:
   31|   111M|      {
   32|   222M|         return ( ( c == Cs ) || ... ) == bool( R );
  ------------------
  |  Branch (32:19): [True: 22, False: 111M]
  |  Branch (32:19): [True: 18, False: 111M]
  ------------------
   33|   111M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   635k|      {
   41|   635k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 635k, False: 107]
  ------------------
   42|   635k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 347, False: 634k]
  ------------------
   43|    347|               bump_help< one >( in, t.size );
   44|    347|               return true;
   45|    347|            }
   46|   635k|         }
   47|   634k|         return false;
   48|   635k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc33EEE4testEc:
   31|   635k|      {
   32|   635k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   635k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|   634k|      {
   41|   634k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 632k, False: 1.26k]
  ------------------
   42|   632k|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 48.7k, False: 584k]
  ------------------
   43|  48.7k|               bump_help< one >( in, t.size );
   44|  48.7k|               return true;
   45|  48.7k|            }
   46|   632k|         }
   47|   585k|         return false;
   48|   634k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc40EEE4testEc:
   31|   632k|      {
   32|   632k|         return ( ( c == Cs ) || ... ) == bool( R );
   33|   632k|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   40|  50.7M|      {
   41|  50.7M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (41:25): [True: 50.7M, False: 287]
  ------------------
   42|  50.7M|            if( test( t.data ) ) {
  ------------------
  |  Branch (42:17): [True: 48.5k, False: 50.7M]
  ------------------
   43|  48.5k|               bump_help< one >( in, t.size );
   44|  48.5k|               return true;
   45|  48.5k|            }
   46|  50.7M|         }
   47|  50.7M|         return false;
   48|  50.7M|      }
_ZN3tao5pegtl8internal3oneILNS1_15result_on_foundE1ENS1_9peek_charEJLc41EEE4testEc:
   31|  50.7M|      {
   32|  50.7M|         return ( ( c == Cs ) || ... ) == bool( R );
   33|  50.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|  46.9k|      {
   47|  46.9k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  46.9k|         return true;
   49|  46.9k|      }
_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|  46.8k|      {
   47|  46.8k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  46.8k|         return true;
   49|  46.8k|      }
_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|  46.7k|      {
   47|  46.7k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  46.7k|         return true;
   49|  46.7k|      }
_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.57k|      {
   47|  3.57k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.57k|         return true;
   49|  3.57k|      }
_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|  4.04k|      {
   47|  4.04k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.04k|         return true;
   49|  4.04k|      }
_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|  6.05k|      {
   47|  6.05k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  6.05k|         return true;
   49|  6.05k|      }
_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|  2.97k|      {
   47|  2.97k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  2.97k|         return true;
   49|  2.97k|      }
_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|  3.42k|      {
   47|  3.42k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.42k|         return true;
   49|  3.42k|      }
_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.03k|      {
   47|  3.03k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  3.03k|         return true;
   49|  3.03k|      }
_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|  4.84k|      {
   47|  4.84k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.84k|         return true;
   49|  4.84k|      }
_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|  4.30k|      {
   47|  4.30k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.30k|         return true;
   49|  4.30k|      }
_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|  7.32k|      {
   47|  7.32k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  7.32k|         return true;
   49|  7.32k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser8negationEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|   635k|      {
   47|   635k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|   635k|         return true;
   49|   635k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser18condition_argumentEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|   634k|      {
   47|   634k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|   634k|         return true;
   49|   634k|      }
_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.07k|      {
   47|  4.07k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  4.07k|         return true;
   49|  4.07k|      }
_ZN3tao5pegtl8internal3optIJN8usbguard10RuleParser7commentEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   46|  42.4k|      {
   47|  42.4k|         (void)Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... );
   48|  42.4k|         return true;
   49|  42.4k|      }

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

_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   129k|      {
   46|   129k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 97.0k, False: 32.2k]
  ------------------
   47|   106k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 9.31k, False: 97.0k]
  ------------------
   48|  9.31k|            }
   49|  97.0k|            return true;
   50|  97.0k|         }
   51|  32.2k|         return false;
   52|   129k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   816k|      {
   46|   816k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 814k, False: 1.46k]
  ------------------
   47|   817k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.30k, False: 814k]
  ------------------
   48|  3.30k|            }
   49|   814k|            return true;
   50|   814k|         }
   51|  1.46k|         return false;
   52|   816k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   354k|      {
   46|   354k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 352k, False: 2.31k]
  ------------------
   47|   355k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.26k, False: 352k]
  ------------------
   48|  3.26k|            }
   49|   352k|            return true;
   50|   352k|         }
   51|  2.31k|         return false;
   52|   354k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  38.9k|      {
   46|  38.9k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 35.0k, False: 3.89k]
  ------------------
   47|  37.6k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.59k, False: 35.0k]
  ------------------
   48|  2.59k|            }
   49|  35.0k|            return true;
   50|  35.0k|         }
   51|  3.89k|         return false;
   52|  38.9k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  8.47k|      {
   46|  8.47k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 6.87k, False: 1.60k]
  ------------------
   47|  8.59k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.72k, False: 6.87k]
  ------------------
   48|  1.72k|            }
   49|  6.87k|            return true;
   50|  6.87k|         }
   51|  1.60k|         return false;
   52|  8.47k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  8.99k|      {
   46|  8.99k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 7.39k, False: 1.59k]
  ------------------
   47|  10.1k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.76k, False: 7.39k]
  ------------------
   48|  2.76k|            }
   49|  7.39k|            return true;
   50|  7.39k|         }
   51|  1.59k|         return false;
   52|  8.99k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  8.24k|      {
   46|  8.24k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 6.86k, False: 1.37k]
  ------------------
   47|  8.89k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 2.03k, False: 6.86k]
  ------------------
   48|  2.03k|            }
   49|  6.86k|            return true;
   50|  6.86k|         }
   51|  1.37k|         return false;
   52|  8.24k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   187k|      {
   46|   187k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 185k, False: 1.98k]
  ------------------
   47|  1.77M|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.58M, False: 185k]
  ------------------
   48|  1.58M|            }
   49|   185k|            return true;
   50|   185k|         }
   51|  1.98k|         return false;
   52|   187k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  14.2k|      {
   46|  14.2k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 11.2k, False: 3.01k]
  ------------------
   47|  14.4k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 3.22k, False: 11.2k]
  ------------------
   48|  3.22k|            }
   49|  11.2k|            return true;
   50|  11.2k|         }
   51|  3.01k|         return false;
   52|  14.2k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|   640k|      {
   46|   640k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 636k, False: 3.40k]
  ------------------
   47|   667k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 31.0k, False: 636k]
  ------------------
   48|  31.0k|            }
   49|   636k|            return true;
   50|   636k|         }
   51|  3.40k|         return false;
   52|   640k|      }
_ZN3tao5pegtl8internal4plusINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   45|  9.86k|      {
   46|  9.86k|         if( Control< Rule >::template match< A, M, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (46:14): [True: 8.00k, False: 1.86k]
  ------------------
   47|  9.58k|            while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (47:20): [True: 1.58k, False: 8.00k]
  ------------------
   48|  1.58k|            }
   49|  8.00k|            return true;
   50|  8.00k|         }
   51|  1.86k|         return false;
   52|  9.86k|      }

_ZN3tao5pegtl8internal5rangeILNS1_15result_on_foundE1ENS1_9peek_charELc48ELc57EE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEEEbRT_:
   39|   745k|      {
   40|   745k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (40:25): [True: 744k, False: 170]
  ------------------
   41|   744k|            if( test( t.data ) ) {
  ------------------
  |  Branch (41:17): [True: 251k, False: 493k]
  ------------------
   42|   251k|               bump_help< range >( in, t.size );
   43|   251k|               return true;
   44|   251k|            }
   45|   744k|         }
   46|   493k|         return false;
   47|   745k|      }
_ZN3tao5pegtl8internal5rangeILNS1_15result_on_foundE1ENS1_9peek_charELc48ELc57EE4testEc:
   30|   744k|      {
   31|   744k|         return ( ( Lo <= c ) && ( c <= Hi ) ) == bool( R );
  ------------------
  |  Branch (31:19): [True: 575k, False: 169k]
  |  Branch (31:34): [True: 251k, False: 323k]
  ------------------
   32|   744k|      }

_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|  3.12M|      {
   60|  3.12M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 3.12M, False: 1.10k]
  ------------------
   61|  3.12M|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 1.28M, False: 1.84M]
  ------------------
   62|  1.28M|               bump_help< ranges >( in, t.size );
   63|  1.28M|               return true;
   64|  1.28M|            }
   65|  3.12M|         }
   66|  1.84M|         return false;
   67|  3.12M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE4testEc:
   50|  3.12M|      {
   51|  3.12M|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|  3.12M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc48ELc57ELc97ELc102ELc65ELc70EEE4testIJLm0ELm1ELm2EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|  3.12M|      {
   40|  3.12M|         constexpr const data_t cs[] = { Cs... };
   41|  3.12M|         if constexpr( sizeof...( Cs ) % 2 == 0 ) {
   42|  11.1M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... );
  ------------------
  |  Branch (42:22): [True: 365k, False: 2.44M]
  |  Branch (42:22): [True: 601k, False: 1.84M]
  |  Branch (42:22): [True: 318k, False: 2.80M]
  ------------------
   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.12M|      }
_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.36M, False: 2.82M]
  |  Branch (25:29): [True: 351k, False: 1.01M]
  ------------------
   26|  4.19M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc97ETnS3_Lc102EEEbS3_:
   23|  2.80M|   {
   24|  2.80M|      static_assert( Lo <= Hi, "invalid range" );
   25|  2.80M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 407k, False: 2.40M]
  |  Branch (25:29): [True: 365k, False: 42.5k]
  ------------------
   26|  2.80M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc65ETnS3_Lc70EEEbS3_:
   23|  2.44M|   {
   24|  2.44M|      static_assert( Lo <= Hi, "invalid range" );
   25|  2.44M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 644k, False: 1.79M]
  |  Branch (25:29): [True: 601k, False: 42.6k]
  ------------------
   26|  2.44M|   }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|   635k|      {
   60|   635k|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 635k, False: 113]
  ------------------
   61|   635k|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 634k, False: 1.03k]
  ------------------
   62|   634k|               bump_help< ranges >( in, t.size );
   63|   634k|               return true;
   64|   634k|            }
   65|   635k|         }
   66|  1.15k|         return false;
   67|   635k|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE4testEc:
   50|   635k|      {
   51|   635k|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|   635k|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc45EEE4testIJLm0ELm1EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|   635k|      {
   40|   635k|         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|   635k|         else {
   45|  1.27M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
  ------------------
  |  Branch (45:22): [True: 634k, False: 1.10k]
  |  Branch (45:22): [True: 34, False: 1.06k]
  |  Branch (45:96): [True: 30, False: 1.03k]
  ------------------
   46|   635k|         }
   47|   635k|      }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc97ETnS3_Lc122EEEbS3_:
   23|  26.1M|   {
   24|  26.1M|      static_assert( Lo <= Hi, "invalid range" );
   25|  26.1M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 5.02M, False: 21.1M]
  |  Branch (25:29): [True: 5.02M, False: 3.74k]
  ------------------
   26|  26.1M|   }
_ZN3tao5pegtl8internal14validate_rangeIcTnT_Lc65ETnS3_Lc90EEEbS3_:
   23|  21.1M|   {
   24|  21.1M|      static_assert( Lo <= Hi, "invalid range" );
   25|  21.1M|      return ( Lo <= c ) && ( c <= Hi );
  ------------------
  |  Branch (25:14): [True: 20.1M, False: 1.06M]
  |  Branch (25:29): [True: 20.1M, False: 3.75k]
  ------------------
   26|  21.1M|   }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEEEbRT_:
   59|  25.5M|      {
   60|  25.5M|         if( const auto t = Peek::peek( in ) ) {
  ------------------
  |  Branch (60:25): [True: 25.5M, False: 1.26k]
  ------------------
   61|  25.5M|            if( test( t.data ) ) {
  ------------------
  |  Branch (61:17): [True: 24.9M, False: 632k]
  ------------------
   62|  24.9M|               bump_help< ranges >( in, t.size );
   63|  24.9M|               return true;
   64|  24.9M|            }
   65|  25.5M|         }
   66|   634k|         return false;
   67|  25.5M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE4testEc:
   50|  25.5M|      {
   51|  25.5M|         return test( std::make_index_sequence< sizeof...( Cs ) / 2 >(), c );
   52|  25.5M|      }
_ZN3tao5pegtl8internal6rangesINS1_9peek_charEJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEE4testIJLm0ELm1ELm2EEEEbNSt3__116integer_sequenceImJXspT_EEEEc:
   39|  25.5M|      {
   40|  25.5M|         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|  25.5M|         else {
   45|  94.5M|            return ( validate_range< data_t, cs[ 2 * Is ], cs[ 2 * Is + 1 ] >( c ) || ... ) || ( c == cs[ sizeof...( Cs ) - 1 ] );
  ------------------
  |  Branch (45:22): [True: 20.1M, False: 1.06M]
  |  Branch (45:22): [True: 32.7k, False: 1.03M]
  |  Branch (45:22): [True: 4.38M, False: 21.1M]
  |  Branch (45:96): [True: 400k, False: 632k]
  ------------------
   46|  25.5M|         }
   47|  25.5M|      }

_ZN3tao5pegtl8internal3repILj4EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  50.4k|      {
   50|  50.4k|         auto m = in.template mark< M >();
   51|  50.4k|         using m_t = decltype( m );
   52|       |
   53|  68.1k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 63.7k, False: 4.43k]
  ------------------
   54|  63.7k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 45.9k, False: 17.7k]
  ------------------
   55|  45.9k|               return false;
   56|  45.9k|            }
   57|  63.7k|         }
   58|  4.43k|         return m( true );
   59|  50.4k|      }
_ZN3tao5pegtl8internal3repILj4EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  1.62M|      {
   50|  1.62M|         auto m = in.template mark< M >();
   51|  1.62M|         using m_t = decltype( m );
   52|       |
   53|  1.63M|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 1.63M, False: 1.86k]
  ------------------
   54|  1.63M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 1.62M, False: 7.60k]
  ------------------
   55|  1.62M|               return false;
   56|  1.62M|            }
   57|  1.63M|         }
   58|  1.86k|         return m( true );
   59|  1.62M|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  83.6k|      {
   50|  83.6k|         auto m = in.template mark< M >();
   51|  83.6k|         using m_t = decltype( m );
   52|       |
   53|   250k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 167k, False: 83.6k]
  ------------------
   54|   167k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 21, False: 167k]
  ------------------
   55|     21|               return false;
   56|     21|            }
   57|   167k|         }
   58|  83.6k|         return m( true );
   59|  83.6k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  18.2k|      {
   50|  18.2k|         auto m = in.template mark< M >();
   51|  18.2k|         using m_t = decltype( m );
   52|       |
   53|  54.6k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 36.4k, False: 18.1k]
  ------------------
   54|  36.4k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 36, False: 36.3k]
  ------------------
   55|     36|               return false;
   56|     36|            }
   57|  36.4k|         }
   58|  18.1k|         return m( true );
   59|  18.2k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  36.0k|      {
   50|  36.0k|         auto m = in.template mark< M >();
   51|  36.0k|         using m_t = decltype( m );
   52|       |
   53|   108k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 72.0k, False: 36.0k]
  ------------------
   54|  72.0k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 36, False: 72.0k]
  ------------------
   55|     36|               return false;
   56|     36|            }
   57|  72.0k|         }
   58|  36.0k|         return m( true );
   59|  36.0k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  5.82k|      {
   50|  5.82k|         auto m = in.template mark< M >();
   51|  5.82k|         using m_t = decltype( m );
   52|       |
   53|  17.4k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 11.6k, False: 5.80k]
  ------------------
   54|  11.6k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 21, False: 11.6k]
  ------------------
   55|     21|               return false;
   56|     21|            }
   57|  11.6k|         }
   58|  5.80k|         return m( true );
   59|  5.82k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  19.7k|      {
   50|  19.7k|         auto m = in.template mark< M >();
   51|  19.7k|         using m_t = decltype( m );
   52|       |
   53|  59.0k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 39.4k, False: 19.6k]
  ------------------
   54|  39.4k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 21, False: 39.3k]
  ------------------
   55|     21|               return false;
   56|     21|            }
   57|  39.4k|         }
   58|  19.6k|         return m( true );
   59|  19.7k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   182k|      {
   50|   182k|         auto m = in.template mark< M >();
   51|   182k|         using m_t = decltype( m );
   52|       |
   53|   543k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 363k, False: 180k]
  ------------------
   54|   363k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 1.96k, False: 361k]
  ------------------
   55|  1.96k|               return false;
   56|  1.96k|            }
   57|   363k|         }
   58|   180k|         return m( true );
   59|   182k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|   361k|      {
   50|   361k|         auto m = in.template mark< M >();
   51|   361k|         using m_t = decltype( m );
   52|       |
   53|   740k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 550k, False: 189k]
  ------------------
   54|   550k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 171k, False: 379k]
  ------------------
   55|   171k|               return false;
   56|   171k|            }
   57|   550k|         }
   58|   189k|         return m( true );
   59|   361k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  25.8k|      {
   50|  25.8k|         auto m = in.template mark< M >();
   51|  25.8k|         using m_t = decltype( m );
   52|       |
   53|  77.5k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 51.7k, False: 25.8k]
  ------------------
   54|  51.7k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 33, False: 51.7k]
  ------------------
   55|     33|               return false;
   56|     33|            }
   57|  51.7k|         }
   58|  25.8k|         return m( true );
   59|  25.8k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  33.2k|      {
   50|  33.2k|         auto m = in.template mark< M >();
   51|  33.2k|         using m_t = decltype( m );
   52|       |
   53|  99.7k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 66.5k, False: 33.2k]
  ------------------
   54|  66.5k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 36, False: 66.4k]
  ------------------
   55|     36|               return false;
   56|     36|            }
   57|  66.5k|         }
   58|  33.2k|         return m( true );
   59|  33.2k|      }
_ZN3tao5pegtl8internal3repILj2EJNS0_5ascii6xdigitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  37.2k|      {
   50|  37.2k|         auto m = in.template mark< M >();
   51|  37.2k|         using m_t = decltype( m );
   52|       |
   53|   111k|         for( unsigned i = 0; i != Cnt; ++i ) {
  ------------------
  |  Branch (53:31): [True: 74.4k, False: 37.1k]
  ------------------
   54|  74.4k|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (54:17): [True: 45, False: 74.4k]
  ------------------
   55|     45|               return false;
   56|     45|            }
   57|  74.4k|         }
   58|  37.1k|         return m( true );
   59|  37.2k|      }

_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  33.5k|      {
   50|  40.0k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 37.6k, False: 2.40k]
  |  Branch (50:47): [True: 6.48k, False: 31.1k]
  ------------------
   51|  6.48k|         }
   52|  33.5k|         return true;
   53|  33.5k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  27.0k|      {
   50|  33.2k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 30.8k, False: 2.48k]
  |  Branch (50:47): [True: 6.27k, False: 24.5k]
  ------------------
   51|  6.27k|         }
   52|  27.0k|         return true;
   53|  27.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|  22.0k|      {
   50|  38.5k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 31.2k, False: 7.26k]
  |  Branch (50:47): [True: 16.4k, False: 14.8k]
  ------------------
   51|  16.4k|         }
   52|  22.0k|         return true;
   53|  22.0k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  8.13k|      {
   50|  9.92k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 9.15k, False: 763]
  |  Branch (50:47): [True: 1.78k, False: 7.37k]
  ------------------
   51|  1.78k|         }
   52|  8.13k|         return true;
   53|  8.13k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  10.1k|      {
   50|  14.8k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 12.9k, False: 1.91k]
  |  Branch (50:47): [True: 4.68k, False: 8.28k]
  ------------------
   51|  4.68k|         }
   52|  10.1k|         return true;
   53|  10.1k|      }
_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|  30.4k|      {
   50|  36.1k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 34.6k, False: 1.45k]
  |  Branch (50:47): [True: 5.63k, False: 29.0k]
  ------------------
   51|  5.63k|         }
   52|  30.4k|         return true;
   53|  30.4k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  31.4k|      {
   50|  43.4k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 41.7k, False: 1.65k]
  |  Branch (50:47): [True: 11.9k, False: 29.8k]
  ------------------
   51|  11.9k|         }
   52|  31.4k|         return true;
   53|  31.4k|      }
_ZN3tao5pegtl8internal7rep_optILj2EJNS0_5ascii5digitEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   49|  27.3k|      {
   50|  35.3k|         for( unsigned i = 0; ( i != Max ) && Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ); ++i ) {
  ------------------
  |  Branch (50:31): [True: 32.7k, False: 2.61k]
  |  Branch (50:47): [True: 8.02k, False: 24.7k]
  ------------------
   51|  8.02k|         }
   52|  27.3k|         return true;
   53|  27.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|  46.9k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  46.9k|         else {
   46|  46.9k|            auto m = in.template mark< M >();
   47|  46.9k|            using m_t = decltype( m );
   48|   183k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 42.6k, False: 4.33k]
  |  Branch (48:25): [True: 38.3k, False: 4.27k]
  |  Branch (48:25): [True: 46.9k, False: 0]
  ------------------
   49|  46.9k|         }
   50|  46.9k|      }
_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|  89.4k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  89.4k|         else {
   46|  89.4k|            auto m = in.template mark< M >();
   47|  89.4k|            using m_t = decltype( m );
   48|   178k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 89.4k, False: 0]
  |  Branch (48:25): [True: 16.4k, False: 72.9k]
  ------------------
   49|  89.4k|         }
   50|  89.4k|      }
_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|  1.72M|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  1.72M|         else {
   46|  1.72M|            auto m = in.template mark< M >();
   47|  1.72M|            using m_t = decltype( m );
   48|  3.42M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.70M, False: 16.4k]
  |  Branch (48:25): [True: 1.70M, False: 0]
  ------------------
   49|  1.72M|         }
   50|  1.72M|      }
_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|  46.9k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  46.9k|         else {
   46|  46.9k|            auto m = in.template mark< M >();
   47|  46.9k|            using m_t = decltype( m );
   48|   361k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 42.4k, False: 0]
  |  Branch (48:25): [True: 42.4k, False: 0]
  |  Branch (48:25): [True: 42.4k, False: 4.32k]
  |  Branch (48:25): [True: 46.7k, False: 3]
  |  Branch (48:25): [True: 46.8k, False: 106]
  ------------------
   49|  46.9k|         }
   50|  46.9k|      }
_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|  46.8k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  46.8k|         else {
   46|  46.8k|            auto m = in.template mark< M >();
   47|  46.8k|            using m_t = decltype( m );
   48|  93.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 46.7k, False: 32]
  |  Branch (48:25): [True: 3.63k, False: 43.1k]
  ------------------
   49|  46.8k|         }
   50|  46.8k|      }
_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|  46.7k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  46.7k|         else {
   46|  46.7k|            auto m = in.template mark< M >();
   47|  46.7k|            using m_t = decltype( m );
   48|  57.7k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.64k, False: 23]
  |  Branch (48:25): [True: 3.63k, False: 10]
  |  Branch (48:25): [True: 3.67k, False: 43.0k]
  ------------------
   49|  46.7k|         }
   50|  46.7k|      }
_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|  46.7k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  46.7k|         else {
   46|  46.7k|            auto m = in.template mark< M >();
   47|  46.7k|            using m_t = decltype( m );
   48|  91.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 44.5k, False: 2.26k]
  |  Branch (48:25): [True: 32.0k, False: 12.4k]
  ------------------
   49|  46.7k|         }
   50|  46.7k|      }
_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|  44.5k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  44.5k|         else {
   46|  44.5k|            auto m = in.template mark< M >();
   47|  44.5k|            using m_t = decltype( m );
   48|  76.9k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 32.3k, False: 12.1k]
  |  Branch (48:25): [True: 32.0k, False: 283]
  ------------------
   49|  44.5k|         }
   50|  44.5k|      }
_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|  50.3k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  50.3k|         else {
   46|  50.3k|            auto m = in.template mark< M >();
   47|  50.3k|            using m_t = decltype( m );
   48|  61.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.57k, False: 16]
  |  Branch (48:25): [True: 3.12k, False: 443]
  |  Branch (48:25): [True: 3.58k, False: 46.7k]
  ------------------
   49|  50.3k|         }
   50|  50.3k|      }
_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.57k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.57k|         else {
   46|  3.57k|            auto m = in.template mark< M >();
   47|  3.57k|            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.40k, False: 0]
  |  Branch (48:25): [True: 2.24k, False: 161]
  |  Branch (48:25): [True: 2.40k, False: 62]
  |  Branch (48:25): [True: 2.46k, False: 0]
  |  Branch (48:25): [True: 2.46k, False: 1.10k]
  |  Branch (48:25): [True: 3.57k, False: 0]
  ------------------
   49|  3.57k|         }
   50|  3.57k|      }
_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.57k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.57k|         else {
   46|  3.57k|            auto m = in.template mark< M >();
   47|  3.57k|            using m_t = decltype( m );
   48|  5.31k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.74k, False: 1.83k]
  |  Branch (48:25): [True: 1.70k, False: 39]
  ------------------
   49|  3.57k|         }
   50|  3.57k|      }
_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.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: 59]
  |  Branch (48:25): [True: 2.40k, False: 3]
  ------------------
   49|  2.46k|         }
   50|  2.46k|      }
_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|   810k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   810k|         else {
   46|   810k|            auto m = in.template mark< M >();
   47|   810k|            using m_t = decltype( m );
   48|  1.62M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 809k, False: 1.40k]
  |  Branch (48:25): [True: 808k, False: 1.00k]
  ------------------
   49|   810k|         }
   50|   810k|      }
_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|   813k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   813k|         else {
   46|   813k|            auto m = in.template mark< M >();
   47|   813k|            using m_t = decltype( m );
   48|  3.24M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 811k, False: 40]
  |  Branch (48:25): [True: 811k, False: 27]
  |  Branch (48:25): [True: 811k, False: 1.42k]
  ------------------
   49|   813k|         }
   50|   813k|      }
_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|  47.1k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  47.1k|         else {
   46|  47.1k|            auto m = in.template mark< M >();
   47|  47.1k|            using m_t = decltype( m );
   48|  59.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.04k, False: 13]
  |  Branch (48:25): [True: 3.39k, False: 655]
  |  Branch (48:25): [True: 4.06k, False: 43.1k]
  ------------------
   49|  47.1k|         }
   50|  47.1k|      }
_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|  4.04k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.04k|         else {
   46|  4.04k|            auto m = in.template mark< M >();
   47|  4.04k|            using m_t = decltype( m );
   48|  33.8k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.06k, False: 0]
  |  Branch (48:25): [True: 2.94k, False: 128]
  |  Branch (48:25): [True: 3.06k, False: 62]
  |  Branch (48:25): [True: 3.13k, False: 0]
  |  Branch (48:25): [True: 3.13k, False: 919]
  |  Branch (48:25): [True: 4.04k, False: 0]
  ------------------
   49|  4.04k|         }
   50|  4.04k|      }
_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|  4.04k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.04k|         else {
   46|  4.04k|            auto m = in.template mark< M >();
   47|  4.04k|            using m_t = decltype( m );
   48|  6.19k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.14k, False: 1.90k]
  |  Branch (48:25): [True: 2.10k, False: 36]
  ------------------
   49|  4.04k|         }
   50|  4.04k|      }
_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|  3.13k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.13k|         else {
   46|  3.13k|            auto m = in.template mark< M >();
   47|  3.13k|            using m_t = decltype( m );
   48|  6.21k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.08k, False: 47]
  |  Branch (48:25): [True: 3.06k, False: 15]
  ------------------
   49|  3.13k|         }
   50|  3.13k|      }
_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|   348k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   348k|         else {
   46|   348k|            auto m = in.template mark< M >();
   47|   348k|            using m_t = decltype( m );
   48|   694k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 346k, False: 2.26k]
  |  Branch (48:25): [True: 345k, False: 818]
  ------------------
   49|   348k|         }
   50|   348k|      }
_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|  43.4k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  43.4k|         else {
   46|  43.4k|            auto m = in.template mark< M >();
   47|  43.4k|            using m_t = decltype( m );
   48|  61.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 6.05k, False: 17]
  |  Branch (48:25): [True: 5.37k, False: 673]
  |  Branch (48:25): [True: 6.06k, False: 37.3k]
  ------------------
   49|  43.4k|         }
   50|  43.4k|      }
_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|  6.05k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  6.05k|         else {
   46|  6.05k|            auto m = in.template mark< M >();
   47|  6.05k|            using m_t = decltype( m );
   48|  50.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.51k, False: 0]
  |  Branch (48:25): [True: 4.37k, False: 137]
  |  Branch (48:25): [True: 4.51k, False: 70]
  |  Branch (48:25): [True: 4.58k, False: 0]
  |  Branch (48:25): [True: 4.58k, False: 1.46k]
  |  Branch (48:25): [True: 6.05k, False: 0]
  ------------------
   49|  6.05k|         }
   50|  6.05k|      }
_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|  6.05k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  6.05k|         else {
   46|  6.05k|            auto m = in.template mark< M >();
   47|  6.05k|            using m_t = decltype( m );
   48|  9.66k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.61k, False: 2.43k]
  |  Branch (48:25): [True: 3.57k, False: 39]
  ------------------
   49|  6.05k|         }
   50|  6.05k|      }
_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|  4.58k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.58k|         else {
   46|  4.58k|            auto m = in.template mark< M >();
   47|  4.58k|            using m_t = decltype( m );
   48|  9.11k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.52k, False: 56]
  |  Branch (48:25): [True: 4.51k, False: 14]
  ------------------
   49|  4.58k|         }
   50|  4.58k|      }
_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|  29.2k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  29.2k|         else {
   46|  29.2k|            auto m = in.template mark< M >();
   47|  29.2k|            using m_t = decltype( m );
   48|  54.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 25.3k, False: 3.83k]
  |  Branch (48:25): [True: 24.6k, False: 691]
  ------------------
   49|  29.2k|         }
   50|  29.2k|      }
_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|  37.7k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  37.7k|         else {
   46|  37.7k|            auto m = in.template mark< M >();
   47|  37.7k|            using m_t = decltype( m );
   48|  46.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.97k, False: 13]
  |  Branch (48:25): [True: 2.39k, False: 587]
  |  Branch (48:25): [True: 2.99k, False: 34.7k]
  ------------------
   49|  37.7k|         }
   50|  37.7k|      }
_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|  2.97k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.97k|         else {
   46|  2.97k|            auto m = in.template mark< M >();
   47|  2.97k|            using m_t = decltype( m );
   48|  22.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.91k, False: 0]
  |  Branch (48:25): [True: 1.80k, False: 114]
  |  Branch (48:25): [True: 1.91k, False: 75]
  |  Branch (48:25): [True: 1.99k, False: 0]
  |  Branch (48:25): [True: 1.99k, False: 985]
  |  Branch (48:25): [True: 2.97k, False: 0]
  ------------------
   49|  2.97k|         }
   50|  2.97k|      }
_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|  2.97k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.97k|         else {
   46|  2.97k|            auto m = in.template mark< M >();
   47|  2.97k|            using m_t = decltype( m );
   48|  4.24k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.26k, False: 1.71k]
  |  Branch (48:25): [True: 1.21k, False: 48]
  ------------------
   49|  2.97k|         }
   50|  2.97k|      }
_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|  1.99k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  1.99k|         else {
   46|  1.99k|            auto m = in.template mark< M >();
   47|  1.99k|            using m_t = decltype( m );
   48|  3.92k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.93k, False: 59]
  |  Branch (48:25): [True: 1.91k, False: 16]
  ------------------
   49|  1.99k|         }
   50|  1.99k|      }
_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|  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|  6.89k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.67k, False: 1.54k]
  |  Branch (48:25): [True: 2.28k, False: 388]
  ------------------
   49|  4.22k|         }
   50|  4.22k|      }
_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|  35.0k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  35.0k|         else {
   46|  35.0k|            auto m = in.template mark< M >();
   47|  35.0k|            using m_t = decltype( m );
   48|  45.3k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.42k, False: 14]
  |  Branch (48:25): [True: 2.96k, False: 457]
  |  Branch (48:25): [True: 3.44k, False: 31.5k]
  ------------------
   49|  35.0k|         }
   50|  35.0k|      }
_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|  3.42k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.42k|         else {
   46|  3.42k|            auto m = in.template mark< M >();
   47|  3.42k|            using m_t = decltype( m );
   48|  23.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.86k, False: 0]
  |  Branch (48:25): [True: 1.76k, False: 96]
  |  Branch (48:25): [True: 1.86k, False: 54]
  |  Branch (48:25): [True: 1.91k, False: 0]
  |  Branch (48:25): [True: 1.91k, False: 1.50k]
  |  Branch (48:25): [True: 3.42k, False: 0]
  ------------------
   49|  3.42k|         }
   50|  3.42k|      }
_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|  3.42k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.42k|         else {
   46|  3.42k|            auto m = in.template mark< M >();
   47|  3.42k|            using m_t = decltype( m );
   48|  4.81k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.38k, False: 2.04k]
  |  Branch (48:25): [True: 1.35k, False: 29]
  ------------------
   49|  3.42k|         }
   50|  3.42k|      }
_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.91k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  1.91k|         else {
   46|  1.91k|            auto m = in.template mark< M >();
   47|  1.91k|            using m_t = decltype( m );
   48|  3.79k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.87k, False: 38]
  |  Branch (48:25): [True: 1.86k, False: 16]
  ------------------
   49|  1.91k|         }
   50|  1.91k|      }
_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|  4.17k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.17k|         else {
   46|  4.17k|            auto m = in.template mark< M >();
   47|  4.17k|            using m_t = decltype( m );
   48|  6.79k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.61k, False: 1.55k]
  |  Branch (48:25): [True: 2.29k, False: 325]
  ------------------
   49|  4.17k|         }
   50|  4.17k|      }
_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|  31.8k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  31.8k|         else {
   46|  31.8k|            auto m = in.template mark< M >();
   47|  31.8k|            using m_t = decltype( m );
   48|  40.9k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.03k, False: 15]
  |  Branch (48:25): [True: 2.39k, False: 634]
  |  Branch (48:25): [True: 3.04k, False: 28.7k]
  ------------------
   49|  31.8k|         }
   50|  31.8k|      }
_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.03k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.03k|         else {
   46|  3.03k|            auto m = in.template mark< M >();
   47|  3.03k|            using m_t = decltype( m );
   48|  22.8k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.91k, False: 0]
  |  Branch (48:25): [True: 1.79k, False: 126]
  |  Branch (48:25): [True: 1.91k, False: 79]
  |  Branch (48:25): [True: 1.99k, False: 0]
  |  Branch (48:25): [True: 1.99k, False: 1.03k]
  |  Branch (48:25): [True: 3.03k, False: 0]
  ------------------
   49|  3.03k|         }
   50|  3.03k|      }
_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.03k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.03k|         else {
   46|  3.03k|            auto m = in.template mark< M >();
   47|  3.03k|            using m_t = decltype( m );
   48|  4.25k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.22k, False: 1.80k]
  |  Branch (48:25): [True: 1.18k, False: 45]
  ------------------
   49|  3.03k|         }
   50|  3.03k|      }
_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|  1.99k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  1.99k|         else {
   46|  1.99k|            auto m = in.template mark< M >();
   47|  1.99k|            using m_t = decltype( m );
   48|  3.93k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.93k, False: 60]
  |  Branch (48:25): [True: 1.91k, False: 19]
  ------------------
   49|  1.99k|         }
   50|  1.99k|      }
_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|  3.97k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.97k|         else {
   46|  3.97k|            auto m = in.template mark< M >();
   47|  3.97k|            using m_t = decltype( m );
   48|  6.62k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.65k, False: 1.31k]
  |  Branch (48:25): [True: 2.03k, False: 622]
  ------------------
   49|  3.97k|         }
   50|  3.97k|      }
_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|  29.1k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  29.1k|         else {
   46|  29.1k|            auto m = in.template mark< M >();
   47|  29.1k|            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: 4.84k, False: 6]
  |  Branch (48:25): [True: 4.44k, False: 401]
  |  Branch (48:25): [True: 4.85k, False: 24.2k]
  ------------------
   49|  29.1k|         }
   50|  29.1k|      }
_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|  4.84k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.84k|         else {
   46|  4.84k|            auto m = in.template mark< M >();
   47|  4.84k|            using m_t = decltype( m );
   48|  39.7k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.56k, False: 0]
  |  Branch (48:25): [True: 3.39k, False: 175]
  |  Branch (48:25): [True: 3.56k, False: 52]
  |  Branch (48:25): [True: 3.61k, False: 0]
  |  Branch (48:25): [True: 3.61k, False: 1.23k]
  |  Branch (48:25): [True: 4.84k, False: 0]
  ------------------
   49|  4.84k|         }
   50|  4.84k|      }
_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|  4.84k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.84k|         else {
   46|  4.84k|            auto m = in.template mark< M >();
   47|  4.84k|            using m_t = decltype( m );
   48|  8.08k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.23k, False: 1.61k]
  |  Branch (48:25): [True: 3.20k, False: 29]
  ------------------
   49|  4.84k|         }
   50|  4.84k|      }
_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|  3.61k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.61k|         else {
   46|  3.61k|            auto m = in.template mark< M >();
   47|  3.61k|            using m_t = decltype( m );
   48|  7.18k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.56k, False: 50]
  |  Branch (48:25): [True: 3.56k, False: 2]
  ------------------
   49|  3.61k|         }
   50|  3.61k|      }
_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|   179k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   179k|         else {
   46|   179k|            auto m = in.template mark< M >();
   47|   179k|            using m_t = decltype( m );
   48|   356k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 177k, False: 1.94k]
  |  Branch (48:25): [True: 175k, False: 1.62k]
  ------------------
   49|   179k|         }
   50|   179k|      }
_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|   182k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   182k|         else {
   46|   182k|            auto m = in.template mark< M >();
   47|   182k|            using m_t = decltype( m );
   48|  1.44M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 180k, False: 18]
  |  Branch (48:25): [True: 180k, False: 15]
  |  Branch (48:25): [True: 180k, False: 31]
  |  Branch (48:25): [True: 180k, False: 34]
  |  Branch (48:25): [True: 180k, False: 1.96k]
  ------------------
   49|   182k|         }
   50|   182k|      }
_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|  24.6k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  24.6k|         else {
   46|  24.6k|            auto m = in.template mark< M >();
   47|  24.6k|            using m_t = decltype( m );
   48|  37.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.30k, False: 8]
  |  Branch (48:25): [True: 3.73k, False: 564]
  |  Branch (48:25): [True: 4.31k, False: 20.3k]
  ------------------
   49|  24.6k|         }
   50|  24.6k|      }
_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|  4.30k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.30k|         else {
   46|  4.30k|            auto m = in.template mark< M >();
   47|  4.30k|            using m_t = decltype( m );
   48|  37.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.42k, False: 0]
  |  Branch (48:25): [True: 3.31k, False: 117]
  |  Branch (48:25): [True: 3.42k, False: 81]
  |  Branch (48:25): [True: 3.50k, False: 0]
  |  Branch (48:25): [True: 3.50k, False: 794]
  |  Branch (48:25): [True: 4.30k, False: 0]
  ------------------
   49|  4.30k|         }
   50|  4.30k|      }
_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|  4.30k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.30k|         else {
   46|  4.30k|            auto m = in.template mark< M >();
   47|  4.30k|            using m_t = decltype( m );
   48|  5.69k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.38k, False: 2.91k]
  |  Branch (48:25): [True: 1.34k, False: 41]
  ------------------
   49|  4.30k|         }
   50|  4.30k|      }
_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|  3.50k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  3.50k|         else {
   46|  3.50k|            auto m = in.template mark< M >();
   47|  3.50k|            using m_t = decltype( m );
   48|  6.95k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.44k, False: 64]
  |  Branch (48:25): [True: 3.42k, False: 17]
  ------------------
   49|  3.50k|         }
   50|  3.50k|      }
_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|  8.54k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  8.54k|         else {
   46|  8.54k|            auto m = in.template mark< M >();
   47|  8.54k|            using m_t = decltype( m );
   48|  14.1k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 5.57k, False: 2.96k]
  |  Branch (48:25): [True: 5.09k, False: 477]
  ------------------
   49|  8.54k|         }
   50|  8.54k|      }
_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|  20.6k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  20.6k|         else {
   46|  20.6k|            auto m = in.template mark< M >();
   47|  20.6k|            using m_t = decltype( m );
   48|  42.6k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 7.32k, False: 23]
  |  Branch (48:25): [True: 4.45k, False: 2.87k]
  |  Branch (48:25): [True: 7.34k, False: 13.2k]
  ------------------
   49|  20.6k|         }
   50|  20.6k|      }
_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|  7.32k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  7.32k|         else {
   46|  7.32k|            auto m = in.template mark< M >();
   47|  7.32k|            using m_t = decltype( m );
   48|  53.0k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 3.73k, False: 0]
  |  Branch (48:25): [True: 3.15k, False: 581]
  |  Branch (48:25): [True: 3.73k, False: 1.23k]
  |  Branch (48:25): [True: 4.97k, False: 0]
  |  Branch (48:25): [True: 4.97k, False: 2.35k]
  |  Branch (48:25): [True: 7.32k, False: 0]
  ------------------
   49|  7.32k|         }
   50|  7.32k|      }
_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|  7.32k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  7.32k|         else {
   46|  7.32k|            auto m = in.template mark< M >();
   47|  7.32k|            using m_t = decltype( m );
   48|  9.47k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.15k, False: 5.17k]
  |  Branch (48:25): [True: 2.07k, False: 76]
  ------------------
   49|  7.32k|         }
   50|  7.32k|      }
_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|  4.97k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.97k|         else {
   46|  4.97k|            auto m = in.template mark< M >();
   47|  4.97k|            using m_t = decltype( m );
   48|  9.81k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.84k, False: 133]
  |  Branch (48:25): [True: 3.73k, False: 1.10k]
  ------------------
   49|  4.97k|         }
   50|  4.97k|      }
_ZN3tao5pegtl8internal3seqIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9conditionEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS8_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   41|   630k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   630k|         else {
   46|   630k|            auto m = in.template mark< M >();
   47|   630k|            using m_t = decltype( m );
   48|  1.25M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 627k, False: 3.30k]
  |  Branch (48:25): [True: 625k, False: 1.53k]
  ------------------
   49|   630k|         }
   50|   630k|      }
_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|   635k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   635k|         else {
   46|   635k|            auto m = in.template mark< M >();
   47|   635k|            using m_t = decltype( m );
   48|  2.53M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 634k, False: 1.15k]
  |  Branch (48:25): [True: 633k, False: 388]
  |  Branch (48:25): [True: 635k, False: 0]
  ------------------
   49|   635k|         }
   50|   635k|      }
_ZN3tao5pegtl8internal3seqIJNS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEENS0_4starINS4_IJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   41|   635k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|   635k|         else {
   46|   635k|            auto m = in.template mark< M >();
   47|   635k|            using m_t = decltype( m );
   48|  1.26M|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 634k, False: 1.15k]
  |  Branch (48:25): [True: 634k, False: 0]
  ------------------
   49|   635k|         }
   50|   635k|      }
_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|  13.9k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  13.9k|         else {
   46|  13.9k|            auto m = in.template mark< M >();
   47|  13.9k|            using m_t = decltype( m );
   48|  26.2k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 4.07k, False: 19]
  |  Branch (48:25): [True: 3.43k, False: 633]
  |  Branch (48:25): [True: 4.09k, False: 9.90k]
  ------------------
   49|  13.9k|         }
   50|  13.9k|      }
_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.07k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.07k|         else {
   46|  4.07k|            auto m = in.template mark< M >();
   47|  4.07k|            using m_t = decltype( m );
   48|  28.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.29k, False: 0]
  |  Branch (48:25): [True: 2.17k, False: 111]
  |  Branch (48:25): [True: 2.29k, False: 75]
  |  Branch (48:25): [True: 2.36k, False: 0]
  |  Branch (48:25): [True: 2.36k, False: 1.70k]
  |  Branch (48:25): [True: 4.07k, False: 0]
  ------------------
   49|  4.07k|         }
   50|  4.07k|      }
_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.07k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.07k|         else {
   46|  4.07k|            auto m = in.template mark< M >();
   47|  4.07k|            using m_t = decltype( m );
   48|  5.51k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 1.44k, False: 2.62k]
  |  Branch (48:25): [True: 1.38k, False: 60]
  ------------------
   49|  4.07k|         }
   50|  4.07k|      }
_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.36k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  2.36k|         else {
   46|  2.36k|            auto m = in.template mark< M >();
   47|  2.36k|            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.29k, False: 67]
  |  Branch (48:25): [True: 2.29k, False: 8]
  ------------------
   49|  2.36k|         }
   50|  2.36k|      }
_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.32k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  4.32k|         else {
   46|  4.32k|            auto m = in.template mark< M >();
   47|  4.32k|            using m_t = decltype( m );
   48|  6.87k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 2.54k, False: 1.78k]
  |  Branch (48:25): [True: 2.02k, False: 516]
  ------------------
   49|  4.32k|         }
   50|  4.32k|      }
_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|  35.7k|      {
   42|       |         if constexpr( sizeof...( Rules ) == 1 ) {
   43|       |            return Control< Rules... >::template match< A, M, Action, Control >( in, st... );
   44|       |         }
   45|  35.7k|         else {
   46|  35.7k|            auto m = in.template mark< M >();
   47|  35.7k|            using m_t = decltype( m );
   48|  41.5k|            return m( ( Control< Rules >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) && ... ) );
  ------------------
  |  Branch (48:25): [True: 5.77k, False: 29.9k]
  |  Branch (48:25): [True: 3.36k, False: 2.41k]
  ------------------
   49|  35.7k|         }
   50|  35.7k|      }

_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  46.9k|      {
   58|  46.9k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  46.9k|      }
_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|  46.9k|      {
   45|  93.8k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 27, False: 46.9k]
  |  Branch (45:19): [True: 46.8k, False: 106]
  ------------------
   46|  46.9k|      }
_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|  46.9k|      {
   58|  46.9k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  46.9k|      }
_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|  46.9k|      {
   45|  57.4k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 711, False: 145]
  |  Branch (45:19): [True: 39, False: 106]
  |  Branch (45:19): [True: 11, False: 856]
  |  Branch (45:19): [True: 2.60k, False: 867]
  |  Branch (45:19): [True: 43.4k, False: 3.47k]
  ------------------
   46|  46.9k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  50.4k|      {
   58|  50.4k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  50.4k|      }
_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|  50.4k|      {
   45|  96.4k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 4.43k, False: 45.9k]
  |  Branch (45:19): [True: 2.88k, False: 43.1k]
  ------------------
   46|  50.4k|      }
_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|  50.3k|      {
   58|  50.3k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  50.3k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser12id_attributeENS4_14name_attributeENS4_14hash_attributeENS4_21parent_hash_attributeENS4_16serial_attributeENS4_18via_port_attributeENS4_24with_interface_attributeENS4_27with_connect_type_attributeENS4_19condition_attributeENS4_15label_attributeEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalEJLm0ELm1ELm2ELm3ELm4ELm5ELm6ELm7ELm8ELm9EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSQ_11char_traitsIcEENSQ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSQ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  50.3k|      {
   45|   603k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 6.64k, False: 13.9k]
  |  Branch (45:19): [True: 3.74k, False: 10.2k]
  |  Branch (45:19): [True: 4.03k, False: 20.6k]
  |  Branch (45:19): [True: 4.45k, False: 24.6k]
  |  Branch (45:19): [True: 2.70k, False: 29.1k]
  |  Branch (45:19): [True: 3.19k, False: 31.8k]
  |  Branch (45:19): [True: 2.68k, False: 35.0k]
  |  Branch (45:19): [True: 5.71k, False: 37.7k]
  |  Branch (45:19): [True: 3.74k, False: 43.4k]
  |  Branch (45:19): [True: 3.14k, False: 47.1k]
  ------------------
   46|  50.3k|      }
_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.57k|      {
   58|  3.57k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.57k|      }
_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.57k|      {
   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.24k, False: 1.32k]
  |  Branch (45:19): [True: 886, False: 437]
  ------------------
   46|  3.57k|      }
_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.57k|      {
   58|  3.57k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.57k|      }
_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.57k|      {
   45|  28.2k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 410, False: 2.02k]
  |  Branch (45:19): [True: 197, False: 1.83k]
  |  Branch (45:19): [True: 197, False: 2.43k]
  |  Branch (45:19): [True: 264, False: 2.63k]
  |  Branch (45:19): [True: 442, False: 2.89k]
  |  Branch (45:19): [True: 231, False: 3.34k]
  ------------------
   46|  3.57k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex4ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|  1.62M|      {
   58|  1.62M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  1.62M|      }
_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.62M|      {
   45|  3.24M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.86k, False: 1.62M]
  |  Branch (45:19): [True: 1.62M, False: 1.45k]
  ------------------
   46|  1.62M|      }
_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|  4.04k|      {
   58|  4.04k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.04k|      }
_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|  4.04k|      {
   45|  5.13k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.96k, False: 1.08k]
  |  Branch (45:19): [True: 779, False: 309]
  ------------------
   46|  4.04k|      }
_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|  4.04k|      {
   58|  4.04k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.04k|      }
_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|  4.04k|      {
   45|  30.0k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 281, False: 2.10k]
  |  Branch (45:19): [True: 202, False: 1.90k]
  |  Branch (45:19): [True: 209, False: 2.38k]
  |  Branch (45:19): [True: 722, False: 2.59k]
  |  Branch (45:19): [True: 337, False: 3.32k]
  |  Branch (45:19): [True: 392, False: 3.65k]
  ------------------
   46|  4.04k|      }
_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|  13.2M|      {
   58|  13.2M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  13.2M|      }
_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|  13.2M|      {
   45|  26.3M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 192k, False: 13.0M]
  |  Branch (45:19): [True: 13.0M, False: 176]
  ------------------
   46|  13.2M|      }
_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|   192k|      {
   58|   192k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   192k|      }
_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|   192k|      {
   45|   562k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 72.2k, False: 2.79k]
  |  Branch (45:19): [True: 2.73k, False: 65]
  |  Branch (45:19): [True: 33.5k, False: 75.0k]
  |  Branch (45:19): [True: 83.6k, False: 108k]
  ------------------
   46|   192k|      }
_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|  6.05k|      {
   58|  6.05k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.05k|      }
_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|  6.05k|      {
   45|  7.69k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 4.40k, False: 1.64k]
  |  Branch (45:19): [True: 1.30k, False: 343]
  ------------------
   46|  6.05k|      }
_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|  6.05k|      {
   58|  6.05k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.05k|      }
_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|  6.05k|      {
   45|  38.6k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 120, False: 2.72k]
  |  Branch (45:19): [True: 287, False: 2.43k]
  |  Branch (45:19): [True: 187, False: 2.84k]
  |  Branch (45:19): [True: 337, False: 3.03k]
  |  Branch (45:19): [True: 2.32k, False: 3.36k]
  |  Branch (45:19): [True: 354, False: 5.69k]
  ------------------
   46|  6.05k|      }
_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|  13.4M|      {
   58|  13.4M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  13.4M|      }
_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|  13.4M|      {
   45|  26.8M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 70.6k, False: 13.3M]
  |  Branch (45:19): [True: 13.3M, False: 177]
  ------------------
   46|  13.4M|      }
_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|  70.6k|      {
   58|  70.6k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  70.6k|      }
_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|  70.6k|      {
   45|   226k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 24.9k, False: 417]
  |  Branch (45:19): [True: 364, False: 53]
  |  Branch (45:19): [True: 27.0k, False: 25.3k]
  |  Branch (45:19): [True: 18.2k, False: 52.4k]
  ------------------
   46|  70.6k|      }
_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|  2.97k|      {
   58|  2.97k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.97k|      }
_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|  2.97k|      {
   45|  4.11k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.84k, False: 1.13k]
  |  Branch (45:19): [True: 843, False: 294]
  ------------------
   46|  2.97k|      }
_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|  2.97k|      {
   58|  2.97k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.97k|      }
_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|  2.97k|      {
   45|  23.7k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 260, False: 1.77k]
  |  Branch (45:19): [True: 68, False: 1.71k]
  |  Branch (45:19): [True: 120, False: 2.03k]
  |  Branch (45:19): [True: 383, False: 2.15k]
  |  Branch (45:19): [True: 227, False: 2.54k]
  |  Branch (45:19): [True: 209, False: 2.76k]
  ------------------
   46|  2.97k|      }
_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|  5.88M|      {
   58|  5.88M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  5.88M|      }
_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|  5.88M|      {
   45|  11.6M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 100k, False: 5.78M]
  |  Branch (45:19): [True: 5.78M, False: 161]
  ------------------
   46|  5.88M|      }
_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|   100k|      {
   58|   100k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   100k|      }
_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|   100k|      {
   45|   314k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 41.6k, False: 718]
  |  Branch (45:19): [True: 658, False: 60]
  |  Branch (45:19): [True: 22.0k, False: 42.3k]
  |  Branch (45:19): [True: 36.0k, False: 64.4k]
  ------------------
   46|   100k|      }
_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|  3.42k|      {
   58|  3.42k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.42k|      }
_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|  3.42k|      {
   45|  5.05k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.79k, False: 1.63k]
  |  Branch (45:19): [True: 1.40k, False: 232]
  ------------------
   46|  3.42k|      }
_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|  3.42k|      {
   58|  3.42k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.42k|      }
_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|  3.42k|      {
   45|  28.7k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 334, False: 2.26k]
  |  Branch (45:19): [True: 222, False: 2.04k]
  |  Branch (45:19): [True: 186, False: 2.59k]
  |  Branch (45:19): [True: 194, False: 2.78k]
  |  Branch (45:19): [True: 200, False: 2.97k]
  |  Branch (45:19): [True: 248, False: 3.17k]
  ------------------
   46|  3.42k|      }
_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.87M|      {
   58|  2.87M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  2.87M|      }
_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.87M|      {
   45|  5.73M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 22.0k, False: 2.85M]
  |  Branch (45:19): [True: 2.85M, False: 165]
  ------------------
   46|  2.87M|      }
_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|  22.0k|      {
   58|  22.0k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  22.0k|      }
_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|  22.0k|      {
   45|  70.9k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 7.72k, False: 352]
  |  Branch (45:19): [True: 332, False: 20]
  |  Branch (45:19): [True: 8.13k, False: 8.07k]
  |  Branch (45:19): [True: 5.82k, False: 16.2k]
  ------------------
   46|  22.0k|      }
_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.03k|      {
   58|  3.03k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.03k|      }
_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.03k|      {
   45|  4.23k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 1.82k, False: 1.20k]
  |  Branch (45:19): [True: 878, False: 329]
  ------------------
   46|  3.03k|      }
_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.03k|      {
   58|  3.03k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  3.03k|      }
_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.03k|      {
   45|  26.6k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 387, False: 2.00k]
  |  Branch (45:19): [True: 195, False: 1.80k]
  |  Branch (45:19): [True: 264, False: 2.38k]
  |  Branch (45:19): [True: 194, False: 2.65k]
  |  Branch (45:19): [True: 95, False: 2.84k]
  |  Branch (45:19): [True: 90, False: 2.94k]
  ------------------
   46|  3.03k|      }
_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.76M|      {
   58|  6.76M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  6.76M|      }
_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.76M|      {
   45|  13.4M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 45.4k, False: 6.72M]
  |  Branch (45:19): [True: 6.72M, False: 183]
  ------------------
   46|  6.76M|      }
_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|  45.4k|      {
   58|  45.4k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  45.4k|      }
_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|  45.4k|      {
   45|   128k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 14.9k, False: 609]
  |  Branch (45:19): [True: 558, False: 51]
  |  Branch (45:19): [True: 10.1k, False: 15.5k]
  |  Branch (45:19): [True: 19.7k, False: 25.7k]
  ------------------
   46|  45.4k|      }
_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|  4.84k|      {
   58|  4.84k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.84k|      }
_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|  4.84k|      {
   45|  6.30k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.39k, False: 1.45k]
  |  Branch (45:19): [True: 1.05k, False: 393]
  ------------------
   46|  4.84k|      }
_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|  4.84k|      {
   58|  4.84k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.84k|      }
_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|  4.84k|      {
   45|  37.8k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 376, False: 2.71k]
  |  Branch (45:19): [True: 1.10k, False: 1.61k]
  |  Branch (45:19): [True: 635, False: 3.08k]
  |  Branch (45:19): [True: 313, False: 3.72k]
  |  Branch (45:19): [True: 272, False: 4.03k]
  |  Branch (45:19): [True: 540, False: 4.30k]
  ------------------
   46|  4.84k|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser4hex2ENS0_5ascii3oneIJLc42EEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   57|   361k|      {
   58|   361k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   361k|      }
_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|   361k|      {
   45|   532k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 189k, False: 171k]
  |  Branch (45:19): [True: 171k, False: 46]
  ------------------
   46|   361k|      }
_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|  4.30k|      {
   58|  4.30k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.30k|      }
_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|  4.30k|      {
   45|  5.25k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 3.35k, False: 949]
  |  Branch (45:19): [True: 675, False: 274]
  ------------------
   46|  4.30k|      }
_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|  4.30k|      {
   58|  4.30k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.30k|      }
_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|  4.30k|      {
   45|  37.9k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 226, False: 3.11k]
  |  Branch (45:19): [True: 204, False: 2.91k]
  |  Branch (45:19): [True: 453, False: 3.34k]
  |  Branch (45:19): [True: 198, False: 3.79k]
  |  Branch (45:19): [True: 117, False: 3.99k]
  |  Branch (45:19): [True: 191, False: 4.11k]
  ------------------
   46|  4.30k|      }
_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|  9.70M|      {
   58|  9.70M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  9.70M|      }
_ZN3tao5pegtl8internal3sorIJN8usbguard10RuleParser17character_escapedILc34EEENS4_17character_regularEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalEJLm0ELm1EENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbNSJ_16integer_sequenceImJXspT3_EEEERT4_DpOT5_:
   44|  9.70M|      {
   45|  19.3M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 99.3k, False: 9.60M]
  |  Branch (45:19): [True: 9.60M, False: 177]
  ------------------
   46|  9.70M|      }
_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|  99.3k|      {
   58|  99.3k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  99.3k|      }
_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|  99.3k|      {
   45|   333k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 41.5k, False: 1.36k]
  |  Branch (45:19): [True: 1.32k, False: 35]
  |  Branch (45:19): [True: 30.4k, False: 42.9k]
  |  Branch (45:19): [True: 25.8k, False: 73.4k]
  ------------------
   46|  99.3k|      }
_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|  7.32k|      {
   58|  7.32k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  7.32k|      }
_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|  7.32k|      {
   45|  10.2k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 4.35k, False: 2.97k]
  |  Branch (45:19): [True: 2.29k, False: 683]
  ------------------
   46|  7.32k|      }
_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|  7.32k|      {
   58|  7.32k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  7.32k|      }
_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|  7.32k|      {
   45|  65.4k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 237, False: 5.38k]
  |  Branch (45:19): [True: 212, False: 5.17k]
  |  Branch (45:19): [True: 1.06k, False: 5.62k]
  |  Branch (45:19): [True: 224, False: 6.69k]
  |  Branch (45:19): [True: 213, False: 6.91k]
  |  Branch (45:19): [True: 196, False: 7.12k]
  ------------------
   46|  7.32k|      }
_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|  50.7M|      {
   58|  50.7M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  50.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|  50.7M|      {
   45|   101M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 146k, False: 50.5M]
  |  Branch (45:19): [True: 50.5M, False: 277]
  ------------------
   46|  50.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|   146k|      {
   58|   146k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|   146k|      }
_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|   146k|      {
   45|   537k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 81.6k, False: 288]
  |  Branch (45:19): [True: 213, False: 75]
  |  Branch (45:19): [True: 31.4k, False: 81.9k]
  |  Branch (45:19): [True: 33.2k, False: 113k]
  ------------------
   46|   146k|      }
_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.07k|      {
   58|  4.07k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.07k|      }
_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.07k|      {
   45|  5.94k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 2.20k, False: 1.86k]
  |  Branch (45:19): [True: 1.54k, False: 325]
  ------------------
   46|  4.07k|      }
_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.07k|      {
   58|  4.07k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  4.07k|      }
_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.07k|      {
   45|  34.5k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 299, False: 2.90k]
  |  Branch (45:19): [True: 279, False: 2.62k]
  |  Branch (45:19): [True: 194, False: 3.20k]
  |  Branch (45:19): [True: 67, False: 3.39k]
  |  Branch (45:19): [True: 245, False: 3.46k]
  |  Branch (45:19): [True: 360, False: 3.71k]
  ------------------
   46|  4.07k|      }
_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|  9.38M|      {
   58|  9.38M|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  9.38M|      }
_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|  9.38M|      {
   45|  18.6M|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 97.0k, False: 9.28M]
  |  Branch (45:19): [True: 9.28M, False: 167]
  ------------------
   46|  9.38M|      }
_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|  97.0k|      {
   58|  97.0k|         return match< A, M, Action, Control >( std::index_sequence_for< Rules... >(), in, st... );
   59|  97.0k|      }
_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|  97.0k|      {
   45|   283k|         return ( Control< Rules >::template match< A, ( ( Indices == ( sizeof...( Rules ) - 1 ) ) ? M : rewind_mode::required ), Action, Control >( in, st... ) || ... );
  ------------------
  |  Branch (45:19): [True: 30.7k, False: 1.73k]
  |  Branch (45:19): [True: 1.66k, False: 64]
  |  Branch (45:19): [True: 27.3k, False: 32.4k]
  |  Branch (45:19): [True: 37.2k, False: 59.8k]
  ------------------
   46|  97.0k|      }

_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|   178k|      {
   41|   201k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 22.5k, False: 178k]
  ------------------
   42|  22.5k|         }
   43|   178k|         return true;
   44|   178k|      }
_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|  16.4k|      {
   41|  1.72M|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.70M, False: 16.4k]
  ------------------
   42|  1.70M|         }
   43|  16.4k|         return true;
   44|  16.4k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.87k|      {
   41|  7.94k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.07k, False: 4.87k]
  ------------------
   42|  3.07k|         }
   43|  4.87k|         return true;
   44|  4.87k|      }
_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.40k|      {
   41|   810k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 808k, False: 2.40k]
  ------------------
   42|   808k|         }
   43|  2.40k|         return true;
   44|  2.40k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  6.19k|      {
   41|  8.56k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.36k, False: 6.19k]
  ------------------
   42|  2.36k|         }
   43|  6.19k|         return true;
   44|  6.19k|      }
_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|  3.08k|      {
   41|   348k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 345k, False: 3.08k]
  ------------------
   42|   345k|         }
   43|  3.08k|         return true;
   44|  3.08k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  9.09k|      {
   41|  11.6k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.51k, False: 9.09k]
  ------------------
   42|  2.51k|         }
   43|  9.09k|         return true;
   44|  9.09k|      }
_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|  4.52k|      {
   41|  29.2k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 24.6k, False: 4.52k]
  ------------------
   42|  24.6k|         }
   43|  4.52k|         return true;
   44|  4.52k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  3.90k|      {
   41|  5.89k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.98k, False: 3.90k]
  ------------------
   42|  1.98k|         }
   43|  3.90k|         return true;
   44|  3.90k|      }
_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|  1.93k|      {
   41|  4.22k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.28k, False: 1.93k]
  ------------------
   42|  2.28k|         }
   43|  1.93k|         return true;
   44|  1.93k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  3.78k|      {
   41|  5.51k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.73k, False: 3.78k]
  ------------------
   42|  1.73k|         }
   43|  3.78k|         return true;
   44|  3.78k|      }
_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.87k|      {
   41|  4.17k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.29k, False: 1.87k]
  ------------------
   42|  2.29k|         }
   43|  1.87k|         return true;
   44|  1.87k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  3.91k|      {
   41|  6.36k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.44k, False: 3.91k]
  ------------------
   42|  2.44k|         }
   43|  3.91k|         return true;
   44|  3.91k|      }
_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|  1.93k|      {
   41|  3.97k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.03k, False: 1.93k]
  ------------------
   42|  2.03k|         }
   43|  1.93k|         return true;
   44|  1.93k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  7.18k|      {
   41|  12.9k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 5.76k, False: 7.18k]
  ------------------
   42|  5.76k|         }
   43|  7.18k|         return true;
   44|  7.18k|      }
_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|  3.56k|      {
   41|   179k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 175k, False: 3.56k]
  ------------------
   42|   175k|         }
   43|  3.56k|         return true;
   44|  3.56k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  6.93k|      {
   41|  9.64k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.70k, False: 6.93k]
  ------------------
   42|  2.70k|         }
   43|  6.93k|         return true;
   44|  6.93k|      }
_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|  3.44k|      {
   41|  8.54k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 5.09k, False: 3.44k]
  ------------------
   42|  5.09k|         }
   43|  3.44k|         return true;
   44|  3.44k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  8.71k|      {
   41|  11.8k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.17k, False: 8.71k]
  ------------------
   42|  3.17k|         }
   43|  8.71k|         return true;
   44|  8.71k|      }
_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|  4.84k|      {
   41|   630k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 625k, False: 4.84k]
  ------------------
   42|   625k|         }
   43|  4.84k|         return true;
   44|  4.84k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   40|   634k|      {
   41|  25.5M|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 24.9M, False: 634k]
  ------------------
   42|  24.9M|         }
   43|   634k|         return true;
   44|   634k|      }
_ZN3tao5pegtl8internal4starINS0_5ascii5blankEJEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   40|  4.65k|      {
   41|  6.24k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 1.59k, False: 4.65k]
  ------------------
   42|  1.59k|         }
   43|  4.65k|         return true;
   44|  4.65k|      }
_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.29k|      {
   41|  4.32k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 2.02k, False: 2.29k]
  ------------------
   42|  2.02k|         }
   43|  2.29k|         return true;
   44|  2.29k|      }
_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|  32.3k|      {
   41|  35.7k|         while( Control< Rule >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (41:17): [True: 3.36k, False: 32.3k]
  ------------------
   42|  3.36k|         }
   43|  32.3k|         return true;
   44|  32.3k|      }

_ZN3tao5pegtl8internal13unsafe_equalsEPKcRKSt16initializer_listIcE:
   23|   509k|   {
   24|   509k|      return std::memcmp( s, &*l.begin(), l.size() ) == 0;
   25|   509k|   }
_ZN3tao5pegtl8internal6stringIJLc97ELc108ELc108ELc111ELc119EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  46.9k|      {
   52|  46.9k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 46.8k, False: 45]
  ------------------
   53|  46.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 43.4k, False: 3.42k]
  ------------------
   54|  43.4k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  43.4k|               return true;
   56|  43.4k|            }
   57|  46.8k|         }
   58|  3.47k|         return false;
   59|  46.9k|      }
_ZN3tao5pegtl8internal6stringIJLc98ELc108ELc111ELc99ELc107EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  3.47k|      {
   52|  3.47k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 3.42k, False: 45]
  ------------------
   53|  3.42k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.60k, False: 822]
  ------------------
   54|  2.60k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.60k|               return true;
   56|  2.60k|            }
   57|  3.42k|         }
   58|    867|         return false;
   59|  3.47k|      }
_ZN3tao5pegtl8internal6stringIJLc114ELc101ELc106ELc101ELc99ELc116EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|    867|      {
   52|    867|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 787, False: 80]
  ------------------
   53|    787|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 11, False: 776]
  ------------------
   54|     11|               bump_help< string >( in, sizeof...( Cs ) );
   55|     11|               return true;
   56|     11|            }
   57|    787|         }
   58|    856|         return false;
   59|    867|      }
_ZN3tao5pegtl8internal6stringIJLc109ELc97ELc116ELc99ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|    856|      {
   52|    856|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 811, False: 45]
  ------------------
   53|    811|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 711, False: 100]
  ------------------
   54|    711|               bump_help< string >( in, sizeof...( Cs ) );
   55|    711|               return true;
   56|    711|            }
   57|    811|         }
   58|    145|         return false;
   59|    856|      }
_ZN3tao5pegtl8internal6stringIJLc100ELc101ELc118ELc105ELc99ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|    145|      {
   52|    145|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 66, False: 79]
  ------------------
   53|     66|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 39, False: 27]
  ------------------
   54|     39|               bump_help< string >( in, sizeof...( Cs ) );
   55|     39|               return true;
   56|     39|            }
   57|     66|         }
   58|    106|         return false;
   59|    145|      }
_ZN3tao5pegtl8internal6stringIJLc105ELc100EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  50.3k|      {
   52|  50.3k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 48.7k, False: 1.56k]
  ------------------
   53|  48.7k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.59k, False: 45.1k]
  ------------------
   54|  3.59k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.59k|               return true;
   56|  3.59k|            }
   57|  48.7k|         }
   58|  46.7k|         return false;
   59|  50.3k|      }
_ZN3tao5pegtl8internal6stringIJLc97ELc108ELc108ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  43.6k|      {
   52|  43.6k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 36.5k, False: 7.12k]
  ------------------
   53|  36.5k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.81k, False: 33.7k]
  ------------------
   54|  2.81k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.81k|               return true;
   56|  2.81k|            }
   57|  36.5k|         }
   58|  40.8k|         return false;
   59|  43.6k|      }
_ZN3tao5pegtl8internal6stringIJLc111ELc110ELc101ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  40.8k|      {
   52|  40.8k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 33.7k, False: 7.12k]
  ------------------
   53|  33.7k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.47k, False: 29.2k]
  ------------------
   54|  4.47k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.47k|               return true;
   56|  4.47k|            }
   57|  33.7k|         }
   58|  36.3k|         return false;
   59|  40.8k|      }
_ZN3tao5pegtl8internal6stringIJLc110ELc111ELc110ELc101ELc45ELc111ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  36.3k|      {
   52|  36.3k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 28.1k, False: 8.22k]
  ------------------
   53|  28.1k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.89k, False: 25.2k]
  ------------------
   54|  2.89k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.89k|               return true;
   56|  2.89k|            }
   57|  28.1k|         }
   58|  33.4k|         return false;
   59|  36.3k|      }
_ZN3tao5pegtl8internal6stringIJLc101ELc113ELc117ELc97ELc108ELc115ELc45ELc111ELc114ELc100ELc101ELc114ELc101ELc100EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  33.4k|      {
   52|  33.4k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 18.0k, False: 15.3k]
  ------------------
   53|  18.0k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.51k, False: 14.5k]
  ------------------
   54|  3.51k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.51k|               return true;
   56|  3.51k|            }
   57|  18.0k|         }
   58|  29.9k|         return false;
   59|  33.4k|      }
_ZN3tao5pegtl8internal6stringIJLc101ELc113ELc117ELc97ELc108ELc115EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  29.9k|      {
   52|  29.9k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 22.8k, False: 7.12k]
  ------------------
   53|  22.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.93k, False: 19.8k]
  ------------------
   54|  2.93k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.93k|               return true;
   56|  2.93k|            }
   57|  22.8k|         }
   58|  27.0k|         return false;
   59|  29.9k|      }
_ZN3tao5pegtl8internal6stringIJLc109ELc97ELc116ELc99ELc104ELc45ELc97ELc108ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  27.0k|      {
   52|  27.0k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 16.8k, False: 10.1k]
  ------------------
   53|  16.8k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.96k, False: 13.9k]
  ------------------
   54|  2.96k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.96k|               return true;
   56|  2.96k|            }
   57|  16.8k|         }
   58|  24.0k|         return false;
   59|  27.0k|      }
_ZN3tao5pegtl8internal6stringIJLc110ELc97ELc109ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  47.1k|      {
   52|  47.1k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 45.3k, False: 1.77k]
  ------------------
   53|  45.3k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.06k, False: 41.3k]
  ------------------
   54|  4.06k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.06k|               return true;
   56|  4.06k|            }
   57|  45.3k|         }
   58|  43.1k|         return false;
   59|  47.1k|      }
_ZN3tao5pegtl8internal6stringIJLc104ELc97ELc115ELc104EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  43.4k|      {
   52|  43.4k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 41.6k, False: 1.77k]
  ------------------
   53|  41.6k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 6.07k, False: 35.5k]
  ------------------
   54|  6.07k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  6.07k|               return true;
   56|  6.07k|            }
   57|  41.6k|         }
   58|  37.3k|         return false;
   59|  43.4k|      }
_ZN3tao5pegtl8internal6stringIJLc112ELc97ELc114ELc101ELc110ELc116ELc45ELc104ELc97ELc115ELc104EEE5matchINS0_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: 32.0k, False: 5.69k]
  ------------------
   53|  32.0k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 2.99k, False: 29.0k]
  ------------------
   54|  2.99k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  2.99k|               return true;
   56|  2.99k|            }
   57|  32.0k|         }
   58|  34.7k|         return false;
   59|  37.7k|      }
_ZN3tao5pegtl8internal6stringIJLc115ELc101ELc114ELc105ELc97ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  35.0k|      {
   52|  35.0k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 32.9k, False: 2.11k]
  ------------------
   53|  32.9k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.44k, False: 29.4k]
  ------------------
   54|  3.44k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.44k|               return true;
   56|  3.44k|            }
   57|  32.9k|         }
   58|  31.5k|         return false;
   59|  35.0k|      }
_ZN3tao5pegtl8internal6stringIJLc118ELc105ELc97ELc45ELc112ELc111ELc114ELc116EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  31.8k|      {
   52|  31.8k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 28.5k, False: 3.26k]
  ------------------
   53|  28.5k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 3.04k, False: 25.5k]
  ------------------
   54|  3.04k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  3.04k|               return true;
   56|  3.04k|            }
   57|  28.5k|         }
   58|  28.7k|         return false;
   59|  31.8k|      }
_ZN3tao5pegtl8internal6stringIJLc119ELc105ELc116ELc104ELc45ELc105ELc110ELc116ELc101ELc114ELc102ELc97ELc99ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  29.1k|      {
   52|  29.1k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 23.2k, False: 5.86k]
  ------------------
   53|  23.2k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.85k, False: 18.4k]
  ------------------
   54|  4.85k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.85k|               return true;
   56|  4.85k|            }
   57|  23.2k|         }
   58|  24.2k|         return false;
   59|  29.1k|      }
_ZN3tao5pegtl8internal6stringIJLc119ELc105ELc116ELc104ELc45ELc99ELc111ELc110ELc110ELc101ELc99ELc116ELc45ELc116ELc121ELc112ELc101EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  24.6k|      {
   52|  24.6k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 17.4k, False: 7.24k]
  ------------------
   53|  17.4k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.31k, False: 13.1k]
  ------------------
   54|  4.31k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.31k|               return true;
   56|  4.31k|            }
   57|  17.4k|         }
   58|  20.3k|         return false;
   59|  24.6k|      }
_ZN3tao5pegtl8internal6stringIJLc105ELc102EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  20.6k|      {
   52|  20.6k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 19.0k, False: 1.56k]
  ------------------
   53|  19.0k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 7.35k, False: 11.7k]
  ------------------
   54|  7.35k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  7.35k|               return true;
   56|  7.35k|            }
   57|  19.0k|         }
   58|  13.2k|         return false;
   59|  20.6k|      }
_ZN3tao5pegtl8internal6stringIJLc108ELc97ELc98ELc101ELc108EEE5matchINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEEEbRT_:
   51|  13.9k|      {
   52|  13.9k|         if( in.size( sizeof...( Cs ) ) >= sizeof...( Cs ) ) {
  ------------------
  |  Branch (52:14): [True: 12.1k, False: 1.88k]
  ------------------
   53|  12.1k|            if( unsafe_equals( in.current(), { Cs... } ) ) {
  ------------------
  |  Branch (53:17): [True: 4.09k, False: 8.01k]
  ------------------
   54|  4.09k|               bump_help< string >( in, sizeof...( Cs ) );
   55|  4.09k|               return true;
   56|  4.09k|            }
   57|  12.1k|         }
   58|  9.90k|         return false;
   59|  13.9k|      }

_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|   349k|      {
   71|   349k|         auto m = in.template mark< M >();
   72|   349k|         using m_t = decltype( m );
   73|       |
   74|  13.6M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 13.2M, False: 348k]
  ------------------
   75|  13.2M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 176, False: 13.2M]
  ------------------
   76|    176|               return false;
   77|    176|            }
   78|  13.2M|         }
   79|   348k|         return m( true );
   80|   349k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  30.5k|      {
   71|  30.5k|         auto m = in.template mark< M >();
   72|  30.5k|         using m_t = decltype( m );
   73|       |
   74|  13.4M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 13.4M, False: 30.3k]
  ------------------
   75|  13.4M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 177, False: 13.4M]
  ------------------
   76|    177|               return false;
   77|    177|            }
   78|  13.4M|         }
   79|  30.3k|         return m( true );
   80|  30.5k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  5.10k|      {
   71|  5.10k|         auto m = in.template mark< M >();
   72|  5.10k|         using m_t = decltype( m );
   73|       |
   74|  5.89M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 5.88M, False: 4.94k]
  ------------------
   75|  5.88M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 161, False: 5.88M]
  ------------------
   76|    161|               return false;
   77|    161|            }
   78|  5.88M|         }
   79|  4.94k|         return m( true );
   80|  5.10k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  5.59k|      {
   71|  5.59k|         auto m = in.template mark< M >();
   72|  5.59k|         using m_t = decltype( m );
   73|       |
   74|  2.88M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 2.87M, False: 5.43k]
  ------------------
   75|  2.87M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 165, False: 2.87M]
  ------------------
   76|    165|               return false;
   77|    165|            }
   78|  2.87M|         }
   79|  5.43k|         return m( true );
   80|  5.59k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  4.87k|      {
   71|  4.87k|         auto m = in.template mark< M >();
   72|  4.87k|         using m_t = decltype( m );
   73|       |
   74|  6.77M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 6.76M, False: 4.69k]
  ------------------
   75|  6.76M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 183, False: 6.76M]
  ------------------
   76|    183|               return false;
   77|    183|            }
   78|  6.76M|         }
   79|  4.69k|         return m( true );
   80|  4.87k|      }
_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|  9.26k|      {
   71|  9.26k|         auto m = in.template mark< M >();
   72|  9.26k|         using m_t = decltype( m );
   73|       |
   74|  9.71M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 9.70M, False: 9.08k]
  ------------------
   75|  9.70M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 177, False: 9.70M]
  ------------------
   76|    177|               return false;
   77|    177|            }
   78|  9.70M|         }
   79|  9.08k|         return m( true );
   80|  9.26k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  48.7k|      {
   71|  48.7k|         auto m = in.template mark< M >();
   72|  48.7k|         using m_t = decltype( m );
   73|       |
   74|  50.7M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 50.7M, False: 48.4k]
  ------------------
   75|  50.7M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 277, False: 50.7M]
  ------------------
   76|    277|               return false;
   77|    277|            }
   78|  50.7M|         }
   79|  48.4k|         return m( true );
   80|  48.7k|      }
_ZN3tao5pegtl8internal5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   70|  5.89k|      {
   71|  5.89k|         auto m = in.template mark< M >();
   72|  5.89k|         using m_t = decltype( m );
   73|       |
   74|  9.38M|         while( !Control< Cond >::template match< A, rewind_mode::required, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (74:17): [True: 9.38M, False: 5.72k]
  ------------------
   75|  9.38M|            if( !Control< Rule >::template match< A, m_t::next_rewind_mode, Action, Control >( in, st... ) ) {
  ------------------
  |  Branch (75:17): [True: 167, False: 9.38M]
  ------------------
   76|    167|               return false;
   77|    167|            }
   78|  9.38M|         }
   79|  5.72k|         return m( true );
   80|  5.89k|      }

_ZN3tao5pegtl5matchIN8usbguard10RuleParser12rule_grammarELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  46.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  46.9k|      else {
  108|  46.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  46.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  46.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|  46.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|  46.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|  46.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|  46.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|  46.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|  46.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  46.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  46.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  46.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|  46.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  46.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  46.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|  46.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  46.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  46.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  46.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  46.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.3k, False: 8.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|  38.3k|            else if constexpr( has_apply0_bool ) {
  153|  38.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.3k|            }
  155|  38.3k|         }
  156|  46.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.3k, False: 8.60k]
  ------------------
  157|  38.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.3k|         }
  159|  8.60k|         else {
  160|  8.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.60k|         }
  162|  46.9k|         (void)m( result );
  163|  46.9k|         return result;
  164|  46.9k|      }
  165|  46.9k|   }
_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|  46.9k|      {
   73|  46.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|  46.9k|         else {
   84|  46.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  46.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  46.9k|      }
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|  46.9k|      {
   44|  46.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  46.9k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   178k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   178k|      else {
  108|   178k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   178k|         using iterator_t = typename ParseInput::iterator_t;
  111|   178k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   178k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   178k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   178k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   178k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   178k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   178k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   178k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   178k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   178k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   178k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   178k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   178k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   178k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   178k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   178k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   178k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   178k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 178k, 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|   178k|            else if constexpr( has_apply0_bool ) {
  153|   178k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   178k|            }
  155|   178k|         }
  156|   178k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 178k, False: 0]
  ------------------
  157|   178k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   178k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   178k|         (void)m( result );
  163|   178k|         return result;
  164|   178k|      }
  165|   178k|   }
_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|   178k|      {
   73|   178k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   178k|         else {
   84|   178k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   178k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   178k|      }
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|   178k|      {
   44|   178k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   178k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   307k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   307k|      else {
  108|   307k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   307k|         using iterator_t = typename ParseInput::iterator_t;
  111|   307k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   307k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   307k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   307k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   307k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   307k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   307k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   307k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   307k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   307k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   307k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   307k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   307k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   307k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   307k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   307k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   307k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   307k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 31.8k, False: 275k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.8k|            else if constexpr( has_apply0_bool ) {
  153|  31.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  31.8k|            }
  155|  31.8k|         }
  156|   307k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 31.8k, False: 275k]
  ------------------
  157|  31.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  31.8k|         }
  159|   275k|         else {
  160|   275k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   275k|         }
  162|   307k|         (void)m( result );
  163|   307k|         return result;
  164|   307k|      }
  165|   307k|   }
_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|   307k|      {
   73|   307k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   307k|         else {
   84|   307k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   307k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   307k|      }
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|   307k|      {
   59|   307k|         return Rule::match( in );
   60|   307k|      }
_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|  46.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  46.9k|      else {
  108|  46.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  46.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  46.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|  46.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|  46.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|  46.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|  46.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|  46.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|  46.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  46.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  46.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  46.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|  46.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  46.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  46.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|  46.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  46.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  46.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  46.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  46.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.6k, False: 4.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|  42.6k|            else if constexpr( has_apply0_bool ) {
  153|  42.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.6k|            }
  155|  42.6k|         }
  156|  46.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.6k, False: 4.33k]
  ------------------
  157|  42.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.6k|         }
  159|  4.33k|         else {
  160|  4.33k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.33k|         }
  162|  46.9k|         (void)m( result );
  163|  46.9k|         return result;
  164|  46.9k|      }
  165|  46.9k|   }
_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|  46.9k|      {
   73|  46.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|  46.9k|         else {
   84|  46.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  46.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  46.9k|      }
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|  46.9k|      {
   44|  46.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  46.9k|      }
_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|  46.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  46.9k|      else {
  108|  46.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  46.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  46.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|  46.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|  46.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|  46.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|  46.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|  46.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|  46.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  46.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  46.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  46.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|  46.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  46.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  46.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|  46.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  46.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  46.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  46.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  46.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.4k, False: 4.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|  42.4k|            else if constexpr( has_apply0_bool ) {
  153|  42.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.4k|            }
  155|  42.4k|         }
  156|  46.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.4k, False: 4.43k]
  ------------------
  157|  42.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.4k|         }
  159|  4.43k|         else {
  160|  4.43k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.43k|         }
  162|  46.9k|         (void)m( result );
  163|  46.9k|         return result;
  164|  46.9k|      }
  165|  46.9k|   }
_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|  46.9k|      {
   73|  46.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|  46.9k|         else {
   84|  46.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  46.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  46.9k|      }
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|  46.9k|      {
   44|  46.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  46.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser7commentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  89.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  89.4k|      else {
  108|  89.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  89.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  89.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|  89.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|  89.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|  89.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): [True: 0, Folded]
  ------------------
  116|  89.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|  89.4k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [True: 89.4k, Folded]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|  89.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  89.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  89.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  89.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|  89.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  89.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  89.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|  89.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  89.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  89.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  89.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  89.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 16.4k, False: 72.9k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|  16.4k|            else if constexpr( has_apply0_void ) {
  150|  16.4k|               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|  16.4k|         }
  156|  89.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 16.4k, False: 72.9k]
  ------------------
  157|  16.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  16.4k|         }
  159|  72.9k|         else {
  160|  72.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  72.9k|         }
  162|  89.4k|         (void)m( result );
  163|  89.4k|         return result;
  164|  89.4k|      }
  165|  89.4k|   }
_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|  89.4k|      {
   73|  89.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|  89.4k|         else {
   84|  89.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  89.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  89.4k|      }
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|  89.4k|      {
   44|  89.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  89.4k|      }
_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|  89.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  89.4k|      else {
  108|  89.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  89.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  89.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|  89.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|  89.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|  89.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|  89.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|  89.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|  89.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  89.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  89.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  89.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|  89.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  89.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  89.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|  89.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  89.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  89.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  89.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  89.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 16.4k, False: 72.9k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.4k|            else if constexpr( has_apply0_bool ) {
  153|  16.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  16.4k|            }
  155|  16.4k|         }
  156|  89.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 16.4k, False: 72.9k]
  ------------------
  157|  16.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  16.4k|         }
  159|  72.9k|         else {
  160|  72.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  72.9k|         }
  162|  89.4k|         (void)m( result );
  163|  89.4k|         return result;
  164|  89.4k|      }
  165|  89.4k|   }
_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|  89.4k|      {
   73|  89.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|  89.4k|         else {
   84|  89.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  89.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  89.4k|      }
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|  89.4k|      {
   44|  89.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  89.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc35EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  89.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  89.4k|      else {
  108|  89.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  89.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  89.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|  89.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|  89.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|  89.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|  89.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|  89.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|  89.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  89.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  89.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  89.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|  89.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  89.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  89.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|  89.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  89.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  89.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  89.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  89.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 16.4k, False: 72.9k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.4k|            else if constexpr( has_apply0_bool ) {
  153|  16.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  16.4k|            }
  155|  16.4k|         }
  156|  89.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 16.4k, False: 72.9k]
  ------------------
  157|  16.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  16.4k|         }
  159|  72.9k|         else {
  160|  72.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  72.9k|         }
  162|  89.4k|         (void)m( result );
  163|  89.4k|         return result;
  164|  89.4k|      }
  165|  89.4k|   }
_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|  89.4k|      {
   73|  89.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|  89.4k|         else {
   84|  89.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  89.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  89.4k|      }
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|  89.4k|      {
   59|  89.4k|         return Rule::match( in );
   60|  89.4k|      }
_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|  16.4k|   {
  104|  16.4k|      if constexpr( !Control< Rule >::enable ) {
  105|  16.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|  16.4k|   }
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|  16.4k|      {
   44|  16.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  16.4k|      }
_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|  16.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.4k|      else {
  108|  16.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.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|  16.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|  16.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|  16.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|  16.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|  16.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|  16.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.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|  16.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 16.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|  16.4k|            else if constexpr( has_apply0_bool ) {
  153|  16.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  16.4k|            }
  155|  16.4k|         }
  156|  16.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 16.4k, False: 0]
  ------------------
  157|  16.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  16.4k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  16.4k|         (void)m( result );
  163|  16.4k|         return result;
  164|  16.4k|      }
  165|  16.4k|   }
_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|  16.4k|      {
   73|  16.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|  16.4k|         else {
   84|  16.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.4k|      }
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|  16.4k|      {
   44|  16.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  16.4k|      }
_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|  1.72M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.72M|      else {
  108|  1.72M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.72M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.72M|         constexpr bool has_apply_void = enable_action && internal::has_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.72M|         constexpr bool has_apply_bool = enable_action && internal::has_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.72M|         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.72M|         constexpr bool has_apply0_void = enable_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.72M|         constexpr bool has_apply0_bool = enable_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.72M|         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.72M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.72M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.72M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.72M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.72M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.72M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.72M|         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.72M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.72M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.72M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.72M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.72M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.70M, False: 16.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.70M|            else if constexpr( has_apply0_bool ) {
  153|  1.70M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.70M|            }
  155|  1.70M|         }
  156|  1.72M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.70M, False: 16.4k]
  ------------------
  157|  1.70M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.70M|         }
  159|  16.4k|         else {
  160|  16.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.4k|         }
  162|  1.72M|         (void)m( result );
  163|  1.72M|         return result;
  164|  1.72M|      }
  165|  1.72M|   }
_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|  1.72M|      {
   73|  1.72M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.72M|         else {
   84|  1.72M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.72M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.72M|      }
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|  1.72M|      {
   44|  1.72M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.72M|      }
_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|  1.72M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.72M|      else {
  108|  1.72M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.72M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.72M|         constexpr bool has_apply_void = enable_action && internal::has_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.72M|         constexpr bool has_apply_bool = enable_action && internal::has_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.72M|         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.72M|         constexpr bool has_apply0_void = enable_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.72M|         constexpr bool has_apply0_bool = enable_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.72M|         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.72M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.72M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.72M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.72M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.72M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.72M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.72M|         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.72M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.72M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.72M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.72M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.72M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.70M, False: 16.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.70M|            else if constexpr( has_apply0_bool ) {
  153|  1.70M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.70M|            }
  155|  1.70M|         }
  156|  1.72M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.70M, False: 16.4k]
  ------------------
  157|  1.70M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.70M|         }
  159|  16.4k|         else {
  160|  16.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.4k|         }
  162|  1.72M|         (void)m( result );
  163|  1.72M|         return result;
  164|  1.72M|      }
  165|  1.72M|   }
_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|  1.72M|      {
   73|  1.72M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.72M|         else {
   84|  1.72M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.72M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.72M|      }
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|  1.72M|      {
   44|  1.72M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.72M|      }
_ZN3tao5pegtl5matchINS0_3eofELNS0_10apply_modeE0ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  1.72M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.72M|      else {
  108|  1.72M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.72M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.72M|         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: 1.72M]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.72M|         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: 1.72M]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.72M|         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.72M|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [Folded, False: 1.72M]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|  1.72M|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [Folded, False: 1.72M]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|  1.72M|         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.72M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.72M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.72M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.72M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.72M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.72M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.72M|         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.72M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.72M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.72M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.72M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.72M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 16.4k, False: 1.70M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.4k|            else if constexpr( has_apply0_bool ) {
  153|  16.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  16.4k|            }
  155|  16.4k|         }
  156|  1.72M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 16.4k, False: 1.70M]
  ------------------
  157|  16.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  16.4k|         }
  159|  1.70M|         else {
  160|  1.70M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.70M|         }
  162|  1.72M|         (void)m( result );
  163|  1.72M|         return result;
  164|  1.72M|      }
  165|  1.72M|   }
_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|  1.72M|      {
   73|  1.72M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.72M|         else {
   84|  1.72M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.72M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.72M|      }
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|  1.72M|      {
   59|  1.72M|         return Rule::match( in );
   60|  1.72M|      }
_ZN3tao5pegtl5matchINS0_5ascii3anyELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  1.70M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.70M|      else {
  108|  1.70M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.70M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.70M|         constexpr bool has_apply_void = enable_action && internal::has_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.70M|         constexpr bool has_apply_bool = enable_action && internal::has_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.70M|         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.70M|         constexpr bool has_apply0_void = enable_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.70M|         constexpr bool has_apply0_bool = enable_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.70M|         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.70M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.70M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.70M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.70M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.70M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.70M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.70M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.70M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.70M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.70M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.70M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.70M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.70M, 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|  1.70M|            else if constexpr( has_apply0_bool ) {
  153|  1.70M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.70M|            }
  155|  1.70M|         }
  156|  1.70M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.70M, False: 0]
  ------------------
  157|  1.70M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.70M|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  1.70M|         (void)m( result );
  163|  1.70M|         return result;
  164|  1.70M|      }
  165|  1.70M|   }
_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|  1.70M|      {
   73|  1.70M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.70M|         else {
   84|  1.70M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.70M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.70M|      }
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|  1.70M|      {
   59|  1.70M|         return Rule::match( in );
   60|  1.70M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4ruleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  46.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  46.9k|      else {
  108|  46.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  46.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  46.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|  46.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|  46.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|  46.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|  46.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|  46.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|  46.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  46.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  46.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  46.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|  46.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  46.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  46.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|  46.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  46.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  46.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  46.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  46.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.4k, False: 4.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|  42.4k|            else if constexpr( has_apply0_bool ) {
  153|  42.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.4k|            }
  155|  42.4k|         }
  156|  46.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.4k, False: 4.43k]
  ------------------
  157|  42.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.4k|         }
  159|  4.43k|         else {
  160|  4.43k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.43k|         }
  162|  46.9k|         (void)m( result );
  163|  46.9k|         return result;
  164|  46.9k|      }
  165|  46.9k|   }
_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|  46.9k|      {
   73|  46.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|  46.9k|         else {
   84|  46.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  46.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  46.9k|      }
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|  46.9k|      {
   44|  46.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  46.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6targetELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  46.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  46.9k|      else {
  108|  46.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  46.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  46.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|  46.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|  46.9k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 46.9k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  46.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|  46.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|  46.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|  46.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  46.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  46.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  46.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|  46.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  46.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  46.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|  46.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 46.9k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  46.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  46.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  46.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  46.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 46.8k, False: 106]
  ------------------
  143|  46.8k|            if constexpr( has_apply_void ) {
  144|  46.8k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  46.8k|         }
  156|  46.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 46.8k, False: 106]
  ------------------
  157|  46.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  46.8k|         }
  159|    106|         else {
  160|    106|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    106|         }
  162|  46.9k|         (void)m( result );
  163|  46.9k|         return result;
  164|  46.9k|      }
  165|  46.9k|   }
_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|  46.9k|      {
   73|  46.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|  46.9k|         else {
   84|  46.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  46.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  46.9k|      }
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|  46.9k|      {
   44|  46.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  46.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_allowELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  46.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  46.9k|      else {
  108|  46.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  46.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  46.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|  46.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|  46.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|  46.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|  46.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|  46.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|  46.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  46.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  46.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  46.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|  46.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  46.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  46.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|  46.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  46.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  46.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  46.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  46.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 43.4k, 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|  43.4k|            else if constexpr( has_apply0_bool ) {
  153|  43.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  43.4k|            }
  155|  43.4k|         }
  156|  46.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 43.4k, False: 3.47k]
  ------------------
  157|  43.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  43.4k|         }
  159|  3.47k|         else {
  160|  3.47k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.47k|         }
  162|  46.9k|         (void)m( result );
  163|  46.9k|         return result;
  164|  46.9k|      }
  165|  46.9k|   }
_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|  46.9k|      {
   73|  46.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|  46.9k|         else {
   84|  46.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  46.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  46.9k|      }
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|  46.9k|      {
   59|  46.9k|         return Rule::match( in );
   60|  46.9k|      }
_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.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: 2.60k, False: 867]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.60k|            else if constexpr( has_apply0_bool ) {
  153|  2.60k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.60k|            }
  155|  2.60k|         }
  156|  3.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.60k, False: 867]
  ------------------
  157|  2.60k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.60k|         }
  159|    867|         else {
  160|    867|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    867|         }
  162|  3.47k|         (void)m( result );
  163|  3.47k|         return result;
  164|  3.47k|      }
  165|  3.47k|   }
_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.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_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.47k|      {
   59|  3.47k|         return Rule::match( in );
   60|  3.47k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_rejectELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|    867|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    867|      else {
  108|    867|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    867|         using iterator_t = typename ParseInput::iterator_t;
  111|    867|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    867|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    867|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    867|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    867|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    867|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    867|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    867|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    867|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    867|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    867|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    867|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    867|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    867|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    867|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    867|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    867|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    867|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 11, False: 856]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|     11|            else if constexpr( has_apply0_bool ) {
  153|     11|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     11|            }
  155|     11|         }
  156|    867|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 11, False: 856]
  ------------------
  157|     11|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     11|         }
  159|    856|         else {
  160|    856|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    856|         }
  162|    867|         (void)m( result );
  163|    867|         return result;
  164|    867|      }
  165|    867|   }
_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|    867|      {
   73|    867|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    867|         else {
   84|    867|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    867|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    867|      }
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|    867|      {
   59|    867|         return Rule::match( in );
   60|    867|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_matchELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|    856|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    856|      else {
  108|    856|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    856|         using iterator_t = typename ParseInput::iterator_t;
  111|    856|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    856|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    856|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    856|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    856|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    856|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    856|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    856|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    856|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    856|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    856|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    856|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    856|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    856|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    856|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    856|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    856|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    856|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 711, False: 145]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    711|            else if constexpr( has_apply0_bool ) {
  153|    711|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    711|            }
  155|    711|         }
  156|    856|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 711, False: 145]
  ------------------
  157|    711|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    711|         }
  159|    145|         else {
  160|    145|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    145|         }
  162|    856|         (void)m( result );
  163|    856|         return result;
  164|    856|      }
  165|    856|   }
_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|    856|      {
   73|    856|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    856|         else {
   84|    856|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    856|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    856|      }
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|    856|      {
   59|    856|         return Rule::match( in );
   60|    856|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_deviceELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|    145|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    145|      else {
  108|    145|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    145|         using iterator_t = typename ParseInput::iterator_t;
  111|    145|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    145|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    145|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    145|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    145|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    145|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    145|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    145|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    145|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    145|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    145|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    145|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    145|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    145|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    145|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    145|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    145|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    145|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 39, False: 106]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|            else if constexpr( has_apply0_bool ) {
  153|     39|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     39|            }
  155|     39|         }
  156|    145|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39, False: 106]
  ------------------
  157|     39|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     39|         }
  159|    106|         else {
  160|    106|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    106|         }
  162|    145|         (void)m( result );
  163|    145|         return result;
  164|    145|      }
  165|    145|   }
_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|    145|      {
   73|    145|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    145|         else {
   84|    145|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    145|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    145|      }
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|    145|      {
   59|    145|         return Rule::match( in );
   60|    145|      }
_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|  46.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  46.8k|      else {
  108|  46.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  46.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  46.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|  46.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|  46.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|  46.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|  46.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|  46.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|  46.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  46.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  46.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  46.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|  46.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  46.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  46.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|  46.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  46.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  46.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  46.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  46.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 46.7k, False: 3]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.7k|            else if constexpr( has_apply0_bool ) {
  153|  46.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  46.7k|            }
  155|  46.7k|         }
  156|  46.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 46.7k, False: 3]
  ------------------
  157|  46.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  46.7k|         }
  159|      3|         else {
  160|      3|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      3|         }
  162|  46.8k|         (void)m( result );
  163|  46.8k|         return result;
  164|  46.8k|      }
  165|  46.8k|   }
_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|  46.8k|      {
   73|  46.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|  46.8k|         else {
   84|  46.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  46.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  46.8k|      }
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|  46.8k|      {
   44|  46.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  46.8k|      }
_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|  46.8k|   {
  104|  46.8k|      if constexpr( !Control< Rule >::enable ) {
  105|  46.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|  46.8k|   }
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|  46.8k|      {
   44|  46.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  46.8k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   129k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   129k|      else {
  108|   129k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   129k|         using iterator_t = typename ParseInput::iterator_t;
  111|   129k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   129k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   129k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   129k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   129k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   129k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   129k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   129k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   129k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   129k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   129k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   129k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   129k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   129k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   129k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   129k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   129k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   129k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 97.0k, False: 32.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|  97.0k|            else if constexpr( has_apply0_bool ) {
  153|  97.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  97.0k|            }
  155|  97.0k|         }
  156|   129k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 97.0k, False: 32.2k]
  ------------------
  157|  97.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  97.0k|         }
  159|  32.2k|         else {
  160|  32.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  32.2k|         }
  162|   129k|         (void)m( result );
  163|   129k|         return result;
  164|   129k|      }
  165|   129k|   }
_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|   129k|      {
   73|   129k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   129k|         else {
   84|   129k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   129k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   129k|      }
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|   129k|      {
   44|   129k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   129k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   129k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   129k|      else {
  108|   129k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   129k|         using iterator_t = typename ParseInput::iterator_t;
  111|   129k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   129k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   129k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   129k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   129k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   129k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   129k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   129k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   129k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   129k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   129k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   129k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   129k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   129k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   129k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   129k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   129k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   129k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 97.0k, False: 32.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|  97.0k|            else if constexpr( has_apply0_bool ) {
  153|  97.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  97.0k|            }
  155|  97.0k|         }
  156|   129k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 97.0k, False: 32.2k]
  ------------------
  157|  97.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  97.0k|         }
  159|  32.2k|         else {
  160|  32.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  32.2k|         }
  162|   129k|         (void)m( result );
  163|   129k|         return result;
  164|   129k|      }
  165|   129k|   }
_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|   129k|      {
   73|   129k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   129k|         else {
   84|   129k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   129k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   129k|      }
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|   129k|      {
   59|   129k|         return Rule::match( in );
   60|   129k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9device_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  46.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  46.7k|      else {
  108|  46.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  46.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  46.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): [True: 0, Folded]
  ------------------
  112|  46.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|  46.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 46.7k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  46.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|  46.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|  46.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|  46.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  46.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  46.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  46.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|  46.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  46.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  46.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|  46.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 46.7k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  46.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  46.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  46.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  46.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.63k, False: 43.1k]
  ------------------
  143|  3.63k|            if constexpr( has_apply_void ) {
  144|  3.63k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.63k|         }
  156|  46.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.63k, False: 43.1k]
  ------------------
  157|  3.63k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.63k|         }
  159|  43.1k|         else {
  160|  43.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  43.1k|         }
  162|  46.7k|         (void)m( result );
  163|  46.7k|         return result;
  164|  46.7k|      }
  165|  46.7k|   }
_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|  46.7k|      {
   73|  46.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|  46.7k|         else {
   84|  46.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  46.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  46.7k|      }
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|  46.7k|      {
   44|  46.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  46.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  46.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  46.7k|      else {
  108|  46.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  46.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  46.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|  46.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|  46.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|  46.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|  46.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|  46.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|  46.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  46.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  46.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  46.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|  46.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  46.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  46.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|  46.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  46.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  46.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  46.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  46.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.67k, False: 43.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|  3.67k|            else if constexpr( has_apply0_bool ) {
  153|  3.67k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.67k|            }
  155|  3.67k|         }
  156|  46.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.67k, False: 43.0k]
  ------------------
  157|  3.67k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.67k|         }
  159|  43.0k|         else {
  160|  43.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  43.0k|         }
  162|  46.7k|         (void)m( result );
  163|  46.7k|         return result;
  164|  46.7k|      }
  165|  46.7k|   }
_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|  46.7k|      {
   73|  46.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|  46.7k|         else {
   84|  46.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  46.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  46.7k|      }
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|  46.7k|      {
   44|  46.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  46.7k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  50.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  50.4k|      else {
  108|  50.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  50.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  50.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  50.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  50.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|  50.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|  50.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|  50.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|  50.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  50.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  50.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  50.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  50.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  50.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  50.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  50.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  50.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  50.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  50.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  50.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.43k, False: 45.9k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.43k|            else if constexpr( has_apply0_bool ) {
  153|  4.43k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.43k|            }
  155|  4.43k|         }
  156|  50.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.43k, False: 45.9k]
  ------------------
  157|  4.43k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.43k|         }
  159|  45.9k|         else {
  160|  45.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  45.9k|         }
  162|  50.4k|         (void)m( result );
  163|  50.4k|         return result;
  164|  50.4k|      }
  165|  50.4k|   }
_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|  50.4k|      {
   73|  50.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|  50.4k|         else {
   84|  50.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  50.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  50.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  50.4k|      {
   44|  50.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  50.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  63.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  63.7k|      else {
  108|  63.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  63.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  63.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|  63.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|  63.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|  63.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|  63.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|  63.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|  63.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  63.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  63.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  63.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|  63.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  63.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  63.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|  63.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  63.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  63.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  63.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  63.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 17.7k, False: 45.9k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  17.7k|            else if constexpr( has_apply0_bool ) {
  153|  17.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  17.7k|            }
  155|  17.7k|         }
  156|  63.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 17.7k, False: 45.9k]
  ------------------
  157|  17.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  17.7k|         }
  159|  45.9k|         else {
  160|  45.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  45.9k|         }
  162|  63.7k|         (void)m( result );
  163|  63.7k|         return result;
  164|  63.7k|      }
  165|  63.7k|   }
_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|  63.7k|      {
   73|  63.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|  63.7k|         else {
   84|  63.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  63.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  63.7k|      }
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|  63.7k|      {
   59|  63.7k|         return Rule::match( in );
   60|  63.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  45.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.9k|      else {
  108|  45.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.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|  45.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|  45.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|  45.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|  45.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|  45.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|  45.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.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|  45.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.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|  45.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.88k, False: 43.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|  2.88k|            else if constexpr( has_apply0_bool ) {
  153|  2.88k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.88k|            }
  155|  2.88k|         }
  156|  45.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.88k, False: 43.1k]
  ------------------
  157|  2.88k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.88k|         }
  159|  43.1k|         else {
  160|  43.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  43.1k|         }
  162|  45.9k|         (void)m( result );
  163|  45.9k|         return result;
  164|  45.9k|      }
  165|  45.9k|   }
_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|  45.9k|      {
   73|  45.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|  45.9k|         else {
   84|  45.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.9k|      }
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|  45.9k|      {
   59|  45.9k|         return Rule::match( in );
   60|  45.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.67k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.67k|      else {
  108|  3.67k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.67k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.67k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.67k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.67k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.67k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.67k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.67k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.67k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.67k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.67k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.67k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.64k, 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|  3.64k|            else if constexpr( has_apply0_bool ) {
  153|  3.64k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.64k|            }
  155|  3.64k|         }
  156|  3.67k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.64k, False: 23]
  ------------------
  157|  3.64k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.64k|         }
  159|     23|         else {
  160|     23|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     23|         }
  162|  3.67k|         (void)m( result );
  163|  3.67k|         return result;
  164|  3.67k|      }
  165|  3.67k|   }
_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|  3.67k|      {
   73|  3.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|  3.67k|         else {
   84|  3.67k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.67k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.67k|      }
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|  3.67k|      {
   59|  3.67k|         return Rule::match( in );
   60|  3.67k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.64k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.64k|      else {
  108|  3.64k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.64k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.64k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.64k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.64k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.64k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.64k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.64k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.64k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.64k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.64k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.64k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.63k, False: 10]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.63k|            else if constexpr( has_apply0_bool ) {
  153|  3.63k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.63k|            }
  155|  3.63k|         }
  156|  3.64k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.63k, False: 10]
  ------------------
  157|  3.63k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.63k|         }
  159|     10|         else {
  160|     10|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     10|         }
  162|  3.64k|         (void)m( result );
  163|  3.64k|         return result;
  164|  3.64k|      }
  165|  3.64k|   }
_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|  3.64k|      {
   73|  3.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|  3.64k|         else {
   84|  3.64k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.64k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.64k|      }
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|  3.64k|      {
   44|  3.64k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.64k|      }
_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|  46.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  46.7k|      else {
  108|  46.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  46.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  46.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|  46.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|  46.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|  46.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|  46.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|  46.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|  46.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  46.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  46.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  46.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|  46.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  46.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  46.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|  46.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  46.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  46.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  46.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  46.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.4k, False: 4.32k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.4k|            else if constexpr( has_apply0_bool ) {
  153|  42.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.4k|            }
  155|  42.4k|         }
  156|  46.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.4k, False: 4.32k]
  ------------------
  157|  42.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.4k|         }
  159|  4.32k|         else {
  160|  4.32k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.32k|         }
  162|  46.7k|         (void)m( result );
  163|  46.7k|         return result;
  164|  46.7k|      }
  165|  46.7k|   }
_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|  46.7k|      {
   73|  46.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|  46.7k|         else {
   84|  46.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  46.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  46.7k|      }
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|  46.7k|      {
   44|  46.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  46.7k|      }
_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|  46.7k|   {
  104|  46.7k|      if constexpr( !Control< Rule >::enable ) {
  105|  46.7k|         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|  46.7k|   }
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|  46.7k|      {
   44|  46.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  46.7k|      }
_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|  44.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  44.5k|      else {
  108|  44.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  44.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  44.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|  44.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|  44.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|  44.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|  44.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|  44.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|  44.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  44.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  44.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  44.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|  44.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  44.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  44.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|  44.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  44.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  44.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  44.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  44.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 32.0k, 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|  32.0k|            else if constexpr( has_apply0_bool ) {
  153|  32.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  32.0k|            }
  155|  32.0k|         }
  156|  44.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 32.0k, False: 12.4k]
  ------------------
  157|  32.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  32.0k|         }
  159|  12.4k|         else {
  160|  12.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  12.4k|         }
  162|  44.5k|         (void)m( result );
  163|  44.5k|         return result;
  164|  44.5k|      }
  165|  44.5k|   }
_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|  44.5k|      {
   73|  44.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|  44.5k|         else {
   84|  44.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  44.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  44.5k|      }
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|  44.5k|      {
   44|  44.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  44.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15rule_attributesELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  50.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  50.3k|      else {
  108|  50.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  50.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  50.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|  50.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|  50.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|  50.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|  50.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|  50.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|  50.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  50.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  50.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  50.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|  50.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  50.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  50.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|  50.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  50.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  50.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  50.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  50.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.7k, False: 14.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|  35.7k|            else if constexpr( has_apply0_bool ) {
  153|  35.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  35.7k|            }
  155|  35.7k|         }
  156|  50.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.7k, False: 14.5k]
  ------------------
  157|  35.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.7k|         }
  159|  14.5k|         else {
  160|  14.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  14.5k|         }
  162|  50.3k|         (void)m( result );
  163|  50.3k|         return result;
  164|  50.3k|      }
  165|  50.3k|   }
_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|  50.3k|      {
   73|  50.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|  50.3k|         else {
   84|  50.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  50.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  50.3k|      }
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|  50.3k|      {
   44|  50.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  50.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12id_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  50.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  50.3k|      else {
  108|  50.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  50.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  50.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|  50.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|  50.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|  50.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|  50.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|  50.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|  50.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  50.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  50.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  50.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|  50.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  50.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  50.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|  50.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  50.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  50.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  50.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  50.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.12k, False: 47.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|  3.12k|            else if constexpr( has_apply0_bool ) {
  153|  3.12k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.12k|            }
  155|  3.12k|         }
  156|  50.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.12k, False: 47.1k]
  ------------------
  157|  3.12k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.12k|         }
  159|  47.1k|         else {
  160|  47.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  47.1k|         }
  162|  50.3k|         (void)m( result );
  163|  50.3k|         return result;
  164|  50.3k|      }
  165|  50.3k|   }
_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|  50.3k|      {
   73|  50.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|  50.3k|         else {
   84|  50.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  50.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  50.3k|      }
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|  50.3k|      {
   44|  50.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  50.3k|      }
_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|  50.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  50.3k|      else {
  108|  50.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  50.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  50.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|  50.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|  50.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|  50.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|  50.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|  50.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|  50.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  50.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  50.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  50.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|  50.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  50.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  50.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|  50.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  50.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  50.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  50.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  50.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.12k, False: 47.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|  3.12k|            else if constexpr( has_apply0_bool ) {
  153|  3.12k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.12k|            }
  155|  3.12k|         }
  156|  50.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.12k, False: 47.1k]
  ------------------
  157|  3.12k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.12k|         }
  159|  47.1k|         else {
  160|  47.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  47.1k|         }
  162|  50.3k|         (void)m( result );
  163|  50.3k|         return result;
  164|  50.3k|      }
  165|  50.3k|   }
_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|  50.3k|      {
   73|  50.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|  50.3k|         else {
   84|  50.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  50.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  50.3k|      }
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|  50.3k|      {
   44|  50.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  50.3k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6str_idELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  50.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  50.3k|      else {
  108|  50.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  50.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  50.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|  50.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|  50.3k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 50.3k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  50.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|  50.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|  50.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|  50.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  50.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  50.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  50.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|  50.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  50.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  50.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|  50.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 50.3k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  50.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  50.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  50.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  50.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.59k, False: 46.7k]
  ------------------
  143|  3.59k|            if constexpr( has_apply_void ) {
  144|  3.59k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.59k|         }
  156|  50.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.58k, False: 46.7k]
  ------------------
  157|  3.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.58k|         }
  159|  46.7k|         else {
  160|  46.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  46.7k|         }
  162|  50.3k|         (void)m( result );
  163|  50.3k|         return result;
  164|  50.3k|      }
  165|  50.3k|   }
_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|  50.3k|      {
   73|  50.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|  50.3k|         else {
   84|  50.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  50.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  50.3k|      }
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|  50.3k|      {
   59|  50.3k|         return Rule::match( in );
   60|  50.3k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   816k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   816k|      else {
  108|   816k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   816k|         using iterator_t = typename ParseInput::iterator_t;
  111|   816k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   816k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   816k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   816k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   816k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   816k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   816k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   816k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   816k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   816k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   816k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   816k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   816k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   816k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   816k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   816k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   816k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   816k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 814k, False: 1.46k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   814k|            else if constexpr( has_apply0_bool ) {
  153|   814k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   814k|            }
  155|   814k|         }
  156|   816k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 814k, False: 1.46k]
  ------------------
  157|   814k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   814k|         }
  159|  1.46k|         else {
  160|  1.46k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.46k|         }
  162|   816k|         (void)m( result );
  163|   816k|         return result;
  164|   816k|      }
  165|   816k|   }
_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|   816k|      {
   73|   816k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   816k|         else {
   84|   816k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   816k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   816k|      }
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|   816k|      {
   44|   816k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   816k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   816k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   816k|      else {
  108|   816k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   816k|         using iterator_t = typename ParseInput::iterator_t;
  111|   816k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   816k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   816k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   816k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   816k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   816k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   816k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   816k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   816k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   816k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   816k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   816k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   816k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   816k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   816k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   816k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   816k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   816k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 814k, False: 1.46k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   814k|            else if constexpr( has_apply0_bool ) {
  153|   814k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   814k|            }
  155|   814k|         }
  156|   816k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 814k, False: 1.46k]
  ------------------
  157|   814k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   814k|         }
  159|  1.46k|         else {
  160|  1.46k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.46k|         }
  162|   816k|         (void)m( result );
  163|   816k|         return result;
  164|   816k|      }
  165|   816k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   816k|      {
   73|   816k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   816k|         else {
   84|   816k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   816k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   816k|      }
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|   816k|      {
   59|   816k|         return Rule::match( in );
   60|   816k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   825k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   825k|      else {
  108|   825k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   825k|         using iterator_t = typename ParseInput::iterator_t;
  111|   825k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   825k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   825k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   825k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   825k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   825k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   825k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   825k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   825k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   825k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   825k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   825k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   825k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   825k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   825k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   825k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   825k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   825k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.37k, False: 819k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.37k|            else if constexpr( has_apply0_bool ) {
  153|  6.37k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.37k|            }
  155|  6.37k|         }
  156|   825k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.37k, False: 819k]
  ------------------
  157|  6.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.37k|         }
  159|   819k|         else {
  160|   819k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   819k|         }
  162|   825k|         (void)m( result );
  163|   825k|         return result;
  164|   825k|      }
  165|   825k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   825k|      {
   73|   825k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   825k|         else {
   84|   825k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   825k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   825k|      }
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|   825k|      {
   59|   825k|         return Rule::match( in );
   60|   825k|      }
_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.57k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.57k|      else {
  108|  3.57k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.57k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.57k|         constexpr bool has_apply_void = enable_action && internal::has_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.57k|         constexpr bool has_apply_bool = enable_action && internal::has_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.57k|         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.57k|         constexpr bool has_apply0_void = enable_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.57k|         constexpr bool has_apply0_bool = enable_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.57k|         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.57k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.57k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.57k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.57k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.57k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.57k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.57k|         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.57k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.57k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.57k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.57k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.57k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.12k, False: 443]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.12k|            else if constexpr( has_apply0_bool ) {
  153|  3.12k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.12k|            }
  155|  3.12k|         }
  156|  3.57k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.12k, False: 443]
  ------------------
  157|  3.12k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.12k|         }
  159|    443|         else {
  160|    443|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    443|         }
  162|  3.57k|         (void)m( result );
  163|  3.57k|         return result;
  164|  3.57k|      }
  165|  3.57k|   }
_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.57k|      {
   73|  3.57k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.57k|         else {
   84|  3.57k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.57k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.57k|      }
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.57k|      {
   44|  3.57k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.57k|      }
_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.57k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.57k|      else {
  108|  3.57k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.57k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.57k|         constexpr bool has_apply_void = enable_action && internal::has_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.57k|         constexpr bool has_apply_bool = enable_action && internal::has_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.57k|         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.57k|         constexpr bool has_apply0_void = enable_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.57k|         constexpr bool has_apply0_bool = enable_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.57k|         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.57k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.57k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.57k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.57k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.57k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.57k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.57k|         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.57k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.57k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.57k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.57k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.57k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.24k, False: 1.32k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.24k|            else if constexpr( has_apply0_bool ) {
  153|  2.24k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.24k|            }
  155|  2.24k|         }
  156|  3.57k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.24k, False: 1.32k]
  ------------------
  157|  2.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.24k|         }
  159|  1.32k|         else {
  160|  1.32k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.32k|         }
  162|  3.57k|         (void)m( result );
  163|  3.57k|         return result;
  164|  3.57k|      }
  165|  3.57k|   }
_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.57k|      {
   73|  3.57k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.57k|         else {
   84|  3.57k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.57k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.57k|      }
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.57k|      {
   44|  3.57k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.57k|      }
_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.57k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.57k|      else {
  108|  3.57k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.57k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.57k|         constexpr bool has_apply_void = enable_action && internal::has_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.57k|         constexpr bool has_apply_bool = enable_action && internal::has_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.57k|         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.57k|         constexpr bool has_apply0_void = enable_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.57k|         constexpr bool has_apply0_bool = enable_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.57k|         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.57k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.57k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.57k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.57k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.57k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.57k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.57k|         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.57k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.57k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.57k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.57k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.57k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.57k, 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.57k|            else if constexpr( has_apply0_bool ) {
  153|  3.57k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.57k|            }
  155|  3.57k|         }
  156|  3.57k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.57k, False: 0]
  ------------------
  157|  3.57k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.57k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.57k|         (void)m( result );
  163|  3.57k|         return result;
  164|  3.57k|      }
  165|  3.57k|   }
_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.57k|      {
   73|  3.57k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.57k|         else {
   84|  3.57k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.57k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.57k|      }
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.57k|      {
   44|  3.57k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.57k|      }
_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.57k|   {
  104|  3.57k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.57k|         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.57k|   }
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.57k|      {
   44|  3.57k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.57k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.57k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.57k|      else {
  108|  3.57k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.57k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.57k|         constexpr bool has_apply_void = 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.57k|         constexpr bool has_apply_bool = enable_action && internal::has_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.57k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.57k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.57k|         constexpr bool has_apply0_void = enable_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.57k|         constexpr bool has_apply0_bool = enable_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.57k|         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.57k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.57k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.57k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.57k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.57k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.57k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.57k|         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.57k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.57k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.57k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.57k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.57k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.57k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.74k, False: 1.83k]
  ------------------
  143|  1.74k|            if constexpr( has_apply_void ) {
  144|  1.74k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.74k|         }
  156|  3.57k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.74k, False: 1.83k]
  ------------------
  157|  1.74k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.74k|         }
  159|  1.83k|         else {
  160|  1.83k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.83k|         }
  162|  3.57k|         (void)m( result );
  163|  3.57k|         return result;
  164|  3.57k|      }
  165|  3.57k|   }
_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.57k|      {
   73|  3.57k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.57k|         else {
   84|  3.57k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.57k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.57k|      }
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.57k|      {
   44|  3.57k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.57k|      }
_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.57k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.57k|      else {
  108|  3.57k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.57k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.57k|         constexpr bool has_apply_void = enable_action && internal::has_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.57k|         constexpr bool has_apply_bool = enable_action && internal::has_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.57k|         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.57k|         constexpr bool has_apply0_void = enable_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.57k|         constexpr bool has_apply0_bool = enable_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.57k|         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.57k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.57k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.57k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.57k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.57k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.57k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.57k|         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.57k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.57k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.57k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.57k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.57k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 231, False: 3.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|    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.57k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 231, False: 3.34k]
  ------------------
  157|    231|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    231|         }
  159|  3.34k|         else {
  160|  3.34k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.34k|         }
  162|  3.57k|         (void)m( result );
  163|  3.57k|         return result;
  164|  3.57k|      }
  165|  3.57k|   }
_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.57k|      {
   73|  3.57k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.57k|         else {
   84|  3.57k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.57k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.57k|      }
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.57k|      {
   59|  3.57k|         return Rule::match( in );
   60|  3.57k|      }
_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.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.34k|      else {
  108|  3.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 442, False: 2.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|    442|            else if constexpr( has_apply0_bool ) {
  153|    442|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    442|            }
  155|    442|         }
  156|  3.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 442, False: 2.89k]
  ------------------
  157|    442|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    442|         }
  159|  2.89k|         else {
  160|  2.89k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.89k|         }
  162|  3.34k|         (void)m( result );
  163|  3.34k|         return result;
  164|  3.34k|      }
  165|  3.34k|   }
_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.34k|      {
   73|  3.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|  3.34k|         else {
   84|  3.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.34k|      }
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.34k|      {
   59|  3.34k|         return Rule::match( in );
   60|  3.34k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_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: 264, False: 2.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|    264|            else if constexpr( has_apply0_bool ) {
  153|    264|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    264|            }
  155|    264|         }
  156|  2.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 264, False: 2.63k]
  ------------------
  157|    264|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    264|         }
  159|  2.63k|         else {
  160|  2.63k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.63k|         }
  162|  2.89k|         (void)m( result );
  163|  2.89k|         return result;
  164|  2.89k|      }
  165|  2.89k|   }
_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|  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_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|  2.89k|      {
   59|  2.89k|         return Rule::match( in );
   60|  2.89k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.63k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.63k|      else {
  108|  2.63k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.63k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.63k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.63k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.63k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.63k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.63k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.63k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.63k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.63k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.63k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.63k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 197, False: 2.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|    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.63k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 197, False: 2.43k]
  ------------------
  157|    197|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    197|         }
  159|  2.43k|         else {
  160|  2.43k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.43k|         }
  162|  2.63k|         (void)m( result );
  163|  2.63k|         return result;
  164|  2.63k|      }
  165|  2.63k|   }
_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|  2.63k|      {
   73|  2.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|  2.63k|         else {
   84|  2.63k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.63k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.63k|      }
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|  2.63k|      {
   59|  2.63k|         return Rule::match( in );
   60|  2.63k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.43k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.43k|      else {
  108|  2.43k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.43k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.43k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.43k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.43k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.43k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.43k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.43k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.43k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.43k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.43k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.43k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 410, False: 2.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|    410|            else if constexpr( has_apply0_bool ) {
  153|    410|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    410|            }
  155|    410|         }
  156|  2.43k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 410, False: 2.02k]
  ------------------
  157|    410|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    410|         }
  159|  2.02k|         else {
  160|  2.02k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.02k|         }
  162|  2.43k|         (void)m( result );
  163|  2.43k|         return result;
  164|  2.43k|      }
  165|  2.43k|   }
_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.43k|      {
   73|  2.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|  2.43k|         else {
   84|  2.43k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.43k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.43k|      }
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.43k|      {
   59|  2.43k|         return Rule::match( in );
   60|  2.43k|      }
_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.02k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.02k|      else {
  108|  2.02k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.02k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.02k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.02k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.02k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.02k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.02k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.02k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.02k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.02k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.02k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.02k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 197, False: 1.83k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.02k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 197, False: 1.83k]
  ------------------
  157|    197|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    197|         }
  159|  1.83k|         else {
  160|  1.83k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.83k|         }
  162|  2.02k|         (void)m( result );
  163|  2.02k|         return result;
  164|  2.02k|      }
  165|  2.02k|   }
_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.02k|      {
   73|  2.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|  2.02k|         else {
   84|  2.02k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.02k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.02k|      }
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.02k|      {
   59|  2.02k|         return Rule::match( in );
   60|  2.02k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.57k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.57k|      else {
  108|  3.57k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.57k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.57k|         constexpr bool has_apply_void = enable_action && internal::has_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.57k|         constexpr bool has_apply_bool = enable_action && internal::has_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.57k|         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.57k|         constexpr bool has_apply0_void = enable_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.57k|         constexpr bool has_apply0_bool = enable_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.57k|         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.57k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.57k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.57k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.57k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.57k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.57k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.57k|         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.57k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.57k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.57k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.57k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.57k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.46k, False: 1.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|  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.57k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.46k, False: 1.10k]
  ------------------
  157|  2.46k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.46k|         }
  159|  1.10k|         else {
  160|  1.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.10k|         }
  162|  3.57k|         (void)m( result );
  163|  3.57k|         return result;
  164|  3.57k|      }
  165|  3.57k|   }
_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.57k|      {
   73|  3.57k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.57k|         else {
   84|  3.57k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.57k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.57k|      }
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.57k|      {
   59|  3.57k|         return Rule::match( in );
   60|  3.57k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.87k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.87k|      else {
  108|  4.87k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.87k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.87k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.87k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.87k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.87k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.87k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.87k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.87k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.87k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.87k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.87k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.87k, 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.87k|            else if constexpr( has_apply0_bool ) {
  153|  4.87k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.87k|            }
  155|  4.87k|         }
  156|  4.87k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.87k, False: 0]
  ------------------
  157|  4.87k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.87k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.87k|         (void)m( result );
  163|  4.87k|         return result;
  164|  4.87k|      }
  165|  4.87k|   }
_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|  4.87k|      {
   73|  4.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|  4.87k|         else {
   84|  4.87k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.87k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.87k|      }
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|  4.87k|      {
   44|  4.87k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.87k|      }
_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.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.40k, 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|  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.46k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.40k, False: 62]
  ------------------
  157|  2.40k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.40k|         }
  159|     62|         else {
  160|     62|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     62|         }
  162|  2.46k|         (void)m( result );
  163|  2.46k|         return result;
  164|  2.46k|      }
  165|  2.46k|   }
_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.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_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.46k|      {
   44|  2.46k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.46k|      }
_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.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_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.40k|      {
   44|  2.40k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.40k|      }
_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|   810k|   {
  104|   810k|      if constexpr( !Control< Rule >::enable ) {
  105|   810k|         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|   810k|   }
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|   810k|      {
   44|   810k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   810k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_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.24k, 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.24k|            else if constexpr( has_apply0_bool ) {
  153|  2.24k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.24k|            }
  155|  2.24k|         }
  156|  2.40k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.24k, False: 161]
  ------------------
  157|  2.24k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.24k|         }
  159|    161|         else {
  160|    161|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    161|         }
  162|  2.40k|         (void)m( result );
  163|  2.40k|         return result;
  164|  2.40k|      }
  165|  2.40k|   }
_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.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_modeE0ETtTpTyEN8usbguard10RuleParser10id_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|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15device_id_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   813k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   813k|      else {
  108|   813k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   813k|         using iterator_t = typename ParseInput::iterator_t;
  111|   813k|         constexpr bool has_apply_void = 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|   813k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   813k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 813k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   813k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   813k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   813k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   813k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   813k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   813k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   813k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   813k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   813k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   813k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   813k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 813k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   813k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   813k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   813k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   813k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 811k, False: 1.49k]
  ------------------
  143|   811k|            if constexpr( has_apply_void ) {
  144|   811k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   811k|         }
  156|   813k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 811k, False: 1.50k]
  ------------------
  157|   811k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   811k|         }
  159|  1.50k|         else {
  160|  1.50k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.50k|         }
  162|   813k|         (void)m( result );
  163|   813k|         return result;
  164|   813k|      }
  165|   813k|   }
_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|   813k|      {
   73|   813k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   813k|         else {
   84|   813k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   813k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   813k|      }
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|   813k|      {
   44|   813k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   813k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_vidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   813k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   813k|      else {
  108|   813k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   813k|         using iterator_t = typename ParseInput::iterator_t;
  111|   813k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   813k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   813k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   813k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   813k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   813k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   813k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   813k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   813k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   813k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   813k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   813k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   813k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   813k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   813k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   813k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   813k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   813k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 811k, False: 1.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|   811k|            else if constexpr( has_apply0_bool ) {
  153|   811k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   811k|            }
  155|   811k|         }
  156|   813k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 811k, False: 1.42k]
  ------------------
  157|   811k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   811k|         }
  159|  1.42k|         else {
  160|  1.42k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.42k|         }
  162|   813k|         (void)m( result );
  163|   813k|         return result;
  164|   813k|      }
  165|   813k|   }
_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|   813k|      {
   73|   813k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   813k|         else {
   84|   813k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   813k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   813k|      }
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|   813k|      {
   44|   813k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   813k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex4ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  1.62M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.62M|      else {
  108|  1.62M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.62M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.62M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.62M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.62M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.62M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.62M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.62M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.62M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.62M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.62M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.62M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.86k, False: 1.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|  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|  1.62M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.86k, False: 1.62M]
  ------------------
  157|  1.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.86k|         }
  159|  1.62M|         else {
  160|  1.62M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.62M|         }
  162|  1.62M|         (void)m( result );
  163|  1.62M|         return result;
  164|  1.62M|      }
  165|  1.62M|   }
_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.62M|      {
   73|  1.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|  1.62M|         else {
   84|  1.62M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.62M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.62M|      }
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.62M|      {
   44|  1.62M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.62M|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  1.63M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.63M|      else {
  108|  1.63M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.63M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.63M|         constexpr bool has_apply_void = enable_action && internal::has_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.63M|         constexpr bool has_apply_bool = enable_action && internal::has_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.63M|         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.63M|         constexpr bool has_apply0_void = enable_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.63M|         constexpr bool has_apply0_bool = enable_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.63M|         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.63M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.63M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.63M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.63M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.63M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.63M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.63M|         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.63M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.63M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.63M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.63M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.63M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.60k, False: 1.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|  7.60k|            else if constexpr( has_apply0_bool ) {
  153|  7.60k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.60k|            }
  155|  7.60k|         }
  156|  1.63M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.60k, False: 1.62M]
  ------------------
  157|  7.60k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.60k|         }
  159|  1.62M|         else {
  160|  1.62M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.62M|         }
  162|  1.63M|         (void)m( result );
  163|  1.63M|         return result;
  164|  1.63M|      }
  165|  1.63M|   }
_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.63M|      {
   73|  1.63M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.63M|         else {
   84|  1.63M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.63M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.63M|      }
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.63M|      {
   59|  1.63M|         return Rule::match( in );
   60|  1.63M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.62M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.62M|      else {
  108|  1.62M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.62M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.62M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.62M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.62M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.62M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.62M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.62M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.62M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.62M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.62M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.62M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.62M, False: 1.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|  1.62M|            else if constexpr( has_apply0_bool ) {
  153|  1.62M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.62M|            }
  155|  1.62M|         }
  156|  1.62M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.62M, False: 1.45k]
  ------------------
  157|  1.62M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.62M|         }
  159|  1.45k|         else {
  160|  1.45k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.45k|         }
  162|  1.62M|         (void)m( result );
  163|  1.62M|         return result;
  164|  1.62M|      }
  165|  1.62M|   }
_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.62M|      {
   73|  1.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|  1.62M|         else {
   84|  1.62M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.62M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.62M|      }
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.62M|      {
   59|  1.62M|         return Rule::match( in );
   60|  1.62M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   811k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   811k|      else {
  108|   811k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   811k|         using iterator_t = typename ParseInput::iterator_t;
  111|   811k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   811k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   811k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   811k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   811k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   811k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   811k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   811k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   811k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   811k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   811k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   811k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   811k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   811k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   811k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   811k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   811k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   811k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 811k, False: 40]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   811k|            else if constexpr( has_apply0_bool ) {
  153|   811k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   811k|            }
  155|   811k|         }
  156|   811k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 811k, False: 40]
  ------------------
  157|   811k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   811k|         }
  159|     40|         else {
  160|     40|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     40|         }
  162|   811k|         (void)m( result );
  163|   811k|         return result;
  164|   811k|      }
  165|   811k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   811k|      {
   73|   811k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   811k|         else {
   84|   811k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   811k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   811k|      }
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|   811k|      {
   59|   811k|         return Rule::match( in );
   60|   811k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10device_pidELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   811k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   811k|      else {
  108|   811k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   811k|         using iterator_t = typename ParseInput::iterator_t;
  111|   811k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   811k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   811k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   811k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   811k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   811k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   811k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   811k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   811k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   811k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   811k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   811k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   811k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   811k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   811k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   811k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   811k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   811k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 811k, 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|   811k|            else if constexpr( has_apply0_bool ) {
  153|   811k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   811k|            }
  155|   811k|         }
  156|   811k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 811k, False: 27]
  ------------------
  157|   811k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   811k|         }
  159|     27|         else {
  160|     27|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     27|         }
  162|   811k|         (void)m( result );
  163|   811k|         return result;
  164|   811k|      }
  165|   811k|   }
_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|   811k|      {
   73|   811k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   811k|         else {
   84|   811k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   811k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   811k|      }
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|   811k|      {
   44|   811k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   811k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14name_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  47.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  47.1k|      else {
  108|  47.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  47.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  47.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|  47.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|  47.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|  47.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|  47.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|  47.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|  47.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  47.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  47.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  47.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|  47.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  47.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  47.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|  47.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  47.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  47.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  47.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  47.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.39k, False: 43.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.39k|            else if constexpr( has_apply0_bool ) {
  153|  3.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.39k|            }
  155|  3.39k|         }
  156|  47.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.39k, False: 43.7k]
  ------------------
  157|  3.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.39k|         }
  159|  43.7k|         else {
  160|  43.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  43.7k|         }
  162|  47.1k|         (void)m( result );
  163|  47.1k|         return result;
  164|  47.1k|      }
  165|  47.1k|   }
_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|  47.1k|      {
   73|  47.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|  47.1k|         else {
   84|  47.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  47.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  47.1k|      }
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|  47.1k|      {
   44|  47.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  47.1k|      }
_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|  47.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  47.1k|      else {
  108|  47.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  47.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  47.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|  47.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|  47.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|  47.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|  47.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|  47.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|  47.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  47.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  47.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  47.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|  47.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  47.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  47.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|  47.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  47.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  47.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  47.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  47.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.39k, False: 43.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.39k|            else if constexpr( has_apply0_bool ) {
  153|  3.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.39k|            }
  155|  3.39k|         }
  156|  47.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.39k, False: 43.7k]
  ------------------
  157|  3.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.39k|         }
  159|  43.7k|         else {
  160|  43.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  43.7k|         }
  162|  47.1k|         (void)m( result );
  163|  47.1k|         return result;
  164|  47.1k|      }
  165|  47.1k|   }
_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|  47.1k|      {
   73|  47.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|  47.1k|         else {
   84|  47.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  47.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  47.1k|      }
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|  47.1k|      {
   44|  47.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  47.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8str_nameELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  47.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  47.1k|      else {
  108|  47.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  47.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  47.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|  47.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|  47.1k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 47.1k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  47.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|  47.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|  47.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|  47.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  47.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  47.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  47.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|  47.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  47.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  47.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|  47.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 47.1k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  47.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  47.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  47.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  47.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.06k, False: 43.1k]
  ------------------
  143|  4.06k|            if constexpr( has_apply_void ) {
  144|  4.06k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.06k|         }
  156|  47.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.06k, False: 43.1k]
  ------------------
  157|  4.06k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.06k|         }
  159|  43.1k|         else {
  160|  43.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  43.1k|         }
  162|  47.1k|         (void)m( result );
  163|  47.1k|         return result;
  164|  47.1k|      }
  165|  47.1k|   }
_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|  47.1k|      {
   73|  47.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|  47.1k|         else {
   84|  47.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  47.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  47.1k|      }
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|  47.1k|      {
   59|  47.1k|         return Rule::match( in );
   60|  47.1k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   354k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   354k|      else {
  108|   354k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   354k|         using iterator_t = typename ParseInput::iterator_t;
  111|   354k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   354k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   354k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   354k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   354k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   354k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   354k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   354k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   354k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   354k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   354k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   354k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   354k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   354k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   354k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   354k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   354k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   354k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 352k, False: 2.31k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   352k|            else if constexpr( has_apply0_bool ) {
  153|   352k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   352k|            }
  155|   352k|         }
  156|   354k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 352k, False: 2.31k]
  ------------------
  157|   352k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   352k|         }
  159|  2.31k|         else {
  160|  2.31k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.31k|         }
  162|   354k|         (void)m( result );
  163|   354k|         return result;
  164|   354k|      }
  165|   354k|   }
_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|   354k|      {
   73|   354k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   354k|         else {
   84|   354k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   354k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   354k|      }
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|   354k|      {
   44|   354k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   354k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   354k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   354k|      else {
  108|   354k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   354k|         using iterator_t = typename ParseInput::iterator_t;
  111|   354k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   354k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   354k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   354k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   354k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   354k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   354k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   354k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   354k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   354k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   354k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   354k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   354k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   354k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   354k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   354k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   354k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   354k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 352k, False: 2.31k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   352k|            else if constexpr( has_apply0_bool ) {
  153|   352k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   352k|            }
  155|   352k|         }
  156|   354k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 352k, False: 2.31k]
  ------------------
  157|   352k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   352k|         }
  159|  2.31k|         else {
  160|  2.31k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.31k|         }
  162|   354k|         (void)m( result );
  163|   354k|         return result;
  164|   354k|      }
  165|   354k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   354k|      {
   73|   354k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   354k|         else {
   84|   354k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   354k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   354k|      }
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|   354k|      {
   59|   354k|         return Rule::match( in );
   60|   354k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   364k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   364k|      else {
  108|   364k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   364k|         using iterator_t = typename ParseInput::iterator_t;
  111|   364k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   364k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   364k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   364k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   364k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   364k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   364k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   364k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   364k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   364k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   364k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   364k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   364k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   364k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   364k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   364k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   364k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   364k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.62k, False: 358k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.62k|            else if constexpr( has_apply0_bool ) {
  153|  5.62k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.62k|            }
  155|  5.62k|         }
  156|   364k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.62k, False: 358k]
  ------------------
  157|  5.62k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.62k|         }
  159|   358k|         else {
  160|   358k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   358k|         }
  162|   364k|         (void)m( result );
  163|   364k|         return result;
  164|   364k|      }
  165|   364k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   364k|      {
   73|   364k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   364k|         else {
   84|   364k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   364k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   364k|      }
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|   364k|      {
   59|   364k|         return Rule::match( in );
   60|   364k|      }
_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|  4.04k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.04k|      else {
  108|  4.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.39k, 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|  3.39k|            else if constexpr( has_apply0_bool ) {
  153|  3.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.39k|            }
  155|  3.39k|         }
  156|  4.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.39k, False: 655]
  ------------------
  157|  3.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.39k|         }
  159|    655|         else {
  160|    655|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    655|         }
  162|  4.04k|         (void)m( result );
  163|  4.04k|         return result;
  164|  4.04k|      }
  165|  4.04k|   }
_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|  4.04k|      {
   73|  4.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|  4.04k|         else {
   84|  4.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.04k|      }
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|  4.04k|      {
   44|  4.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.04k|      }
_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|  4.04k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.04k|      else {
  108|  4.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.94k, False: 1.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|  2.94k|            else if constexpr( has_apply0_bool ) {
  153|  2.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.94k|            }
  155|  2.94k|         }
  156|  4.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.94k, False: 1.10k]
  ------------------
  157|  2.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.94k|         }
  159|  1.10k|         else {
  160|  1.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.10k|         }
  162|  4.04k|         (void)m( result );
  163|  4.04k|         return result;
  164|  4.04k|      }
  165|  4.04k|   }
_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|  4.04k|      {
   73|  4.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|  4.04k|         else {
   84|  4.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.04k|      }
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|  4.04k|      {
   44|  4.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.04k|      }
_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|  4.04k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.04k|      else {
  108|  4.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.04k, 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.04k|            else if constexpr( has_apply0_bool ) {
  153|  4.04k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.04k|            }
  155|  4.04k|         }
  156|  4.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.04k, False: 0]
  ------------------
  157|  4.04k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.04k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.04k|         (void)m( result );
  163|  4.04k|         return result;
  164|  4.04k|      }
  165|  4.04k|   }
_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|  4.04k|      {
   73|  4.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|  4.04k|         else {
   84|  4.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.04k|      }
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|  4.04k|      {
   44|  4.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.04k|      }
_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|  4.04k|   {
  104|  4.04k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.04k|         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.04k|   }
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|  4.04k|      {
   44|  4.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.04k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.04k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.04k|      else {
  108|  4.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.04k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.04k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.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|  4.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|  4.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|  4.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.04k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.14k, False: 1.90k]
  ------------------
  143|  2.14k|            if constexpr( has_apply_void ) {
  144|  2.14k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.14k|         }
  156|  4.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.14k, False: 1.90k]
  ------------------
  157|  2.14k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.14k|         }
  159|  1.90k|         else {
  160|  1.90k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.90k|         }
  162|  4.04k|         (void)m( result );
  163|  4.04k|         return result;
  164|  4.04k|      }
  165|  4.04k|   }
_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|  4.04k|      {
   73|  4.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|  4.04k|         else {
   84|  4.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.04k|      }
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|  4.04k|      {
   44|  4.04k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.04k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.04k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.04k|      else {
  108|  4.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 392, False: 3.65k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    392|            else if constexpr( has_apply0_bool ) {
  153|    392|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    392|            }
  155|    392|         }
  156|  4.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 392, False: 3.65k]
  ------------------
  157|    392|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    392|         }
  159|  3.65k|         else {
  160|  3.65k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.65k|         }
  162|  4.04k|         (void)m( result );
  163|  4.04k|         return result;
  164|  4.04k|      }
  165|  4.04k|   }
_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|  4.04k|      {
   73|  4.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|  4.04k|         else {
   84|  4.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.04k|      }
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|  4.04k|      {
   59|  4.04k|         return Rule::match( in );
   60|  4.04k|      }
_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.65k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.65k|      else {
  108|  3.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.65k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.65k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.65k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.65k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 337, False: 3.32k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    337|            else if constexpr( has_apply0_bool ) {
  153|    337|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    337|            }
  155|    337|         }
  156|  3.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 337, False: 3.32k]
  ------------------
  157|    337|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    337|         }
  159|  3.32k|         else {
  160|  3.32k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.32k|         }
  162|  3.65k|         (void)m( result );
  163|  3.65k|         return result;
  164|  3.65k|      }
  165|  3.65k|   }
_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.65k|      {
   73|  3.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|  3.65k|         else {
   84|  3.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.65k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.65k|      {
   59|  3.65k|         return Rule::match( in );
   60|  3.65k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.32k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.32k|      else {
  108|  3.32k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.32k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.32k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.32k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.32k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.32k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.32k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.32k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.32k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.32k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.32k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.32k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.32k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.32k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.32k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.32k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 722, 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|    722|            else if constexpr( has_apply0_bool ) {
  153|    722|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    722|            }
  155|    722|         }
  156|  3.32k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 722, False: 2.59k]
  ------------------
  157|    722|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    722|         }
  159|  2.59k|         else {
  160|  2.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.59k|         }
  162|  3.32k|         (void)m( result );
  163|  3.32k|         return result;
  164|  3.32k|      }
  165|  3.32k|   }
_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|  3.32k|      {
   73|  3.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|  3.32k|         else {
   84|  3.32k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.32k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.32k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  3.32k|      {
   59|  3.32k|         return Rule::match( in );
   60|  3.32k|      }
_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.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: 209, False: 2.38k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  2.59k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 209, False: 2.38k]
  ------------------
  157|    209|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    209|         }
  159|  2.38k|         else {
  160|  2.38k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.38k|         }
  162|  2.59k|         (void)m( result );
  163|  2.59k|         return result;
  164|  2.59k|      }
  165|  2.59k|   }
_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.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_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.59k|      {
   59|  2.59k|         return Rule::match( in );
   60|  2.59k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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: 281, 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|    281|            else if constexpr( has_apply0_bool ) {
  153|    281|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    281|            }
  155|    281|         }
  156|  2.38k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 281, False: 2.10k]
  ------------------
  157|    281|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    281|         }
  159|  2.10k|         else {
  160|  2.10k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.10k|         }
  162|  2.38k|         (void)m( result );
  163|  2.38k|         return result;
  164|  2.38k|      }
  165|  2.38k|   }
_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.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_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.38k|      {
   59|  2.38k|         return Rule::match( in );
   60|  2.38k|      }
_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.10k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.10k|      else {
  108|  2.10k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.10k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.10k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.10k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.10k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.10k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.10k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.10k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.10k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.10k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.10k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.10k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 202, 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|    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.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 202, False: 1.90k]
  ------------------
  157|    202|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    202|         }
  159|  1.90k|         else {
  160|  1.90k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.90k|         }
  162|  2.10k|         (void)m( result );
  163|  2.10k|         return result;
  164|  2.10k|      }
  165|  2.10k|   }
_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.10k|      {
   73|  2.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|  2.10k|         else {
   84|  2.10k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.10k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.10k|      }
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.10k|      {
   59|  2.10k|         return Rule::match( in );
   60|  2.10k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.04k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.04k|      else {
  108|  4.04k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.04k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.04k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.04k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.04k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.04k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.04k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.04k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.04k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.04k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.04k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.04k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.13k, False: 919]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.13k|            else if constexpr( has_apply0_bool ) {
  153|  3.13k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.13k|            }
  155|  3.13k|         }
  156|  4.04k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.13k, False: 919]
  ------------------
  157|  3.13k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.13k|         }
  159|    919|         else {
  160|    919|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    919|         }
  162|  4.04k|         (void)m( result );
  163|  4.04k|         return result;
  164|  4.04k|      }
  165|  4.04k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  4.04k|      {
   73|  4.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|  4.04k|         else {
   84|  4.04k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.04k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.04k|      }
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|  4.04k|      {
   59|  4.04k|         return Rule::match( in );
   60|  4.04k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  6.19k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.19k|      else {
  108|  6.19k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.19k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.19k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.19k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.19k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.19k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.19k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.19k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.19k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.19k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.19k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.19k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.19k, 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.19k|            else if constexpr( has_apply0_bool ) {
  153|  6.19k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.19k|            }
  155|  6.19k|         }
  156|  6.19k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.19k, False: 0]
  ------------------
  157|  6.19k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.19k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.19k|         (void)m( result );
  163|  6.19k|         return result;
  164|  6.19k|      }
  165|  6.19k|   }
_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|  6.19k|      {
   73|  6.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|  6.19k|         else {
   84|  6.19k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.19k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.19k|      }
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|  6.19k|      {
   44|  6.19k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.19k|      }
_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|  3.13k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.13k|      else {
  108|  3.13k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.13k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.13k|         constexpr bool has_apply_void = enable_action && internal::has_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.13k|         constexpr bool has_apply_bool = enable_action && internal::has_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.13k|         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.13k|         constexpr bool has_apply0_void = enable_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.13k|         constexpr bool has_apply0_bool = enable_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.13k|         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.13k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.13k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.13k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.13k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.13k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.13k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.13k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.13k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.13k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.13k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.13k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.13k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.06k, 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|  3.06k|            else if constexpr( has_apply0_bool ) {
  153|  3.06k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.06k|            }
  155|  3.06k|         }
  156|  3.13k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.06k, False: 62]
  ------------------
  157|  3.06k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.06k|         }
  159|     62|         else {
  160|     62|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     62|         }
  162|  3.13k|         (void)m( result );
  163|  3.13k|         return result;
  164|  3.13k|      }
  165|  3.13k|   }
_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|  3.13k|      {
   73|  3.13k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.13k|         else {
   84|  3.13k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.13k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.13k|      }
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|  3.13k|      {
   44|  3.13k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.13k|      }
_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|  3.08k|   {
  104|  3.08k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.08k|         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.08k|   }
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|  3.08k|      {
   44|  3.08k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.08k|      }
_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|   348k|   {
  104|   348k|      if constexpr( !Control< Rule >::enable ) {
  105|   348k|         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|   348k|   }
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|   348k|      {
   44|   348k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   348k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.06k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.06k|      else {
  108|  3.06k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.06k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.06k|         constexpr bool has_apply_void = enable_action && internal::has_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.06k|         constexpr bool has_apply_bool = enable_action && internal::has_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.06k|         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.06k|         constexpr bool has_apply0_void = enable_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.06k|         constexpr bool has_apply0_bool = enable_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.06k|         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.06k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.06k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.06k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.06k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.06k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.06k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.06k|         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.06k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.06k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.06k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.06k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.06k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.94k, False: 128]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.94k|            else if constexpr( has_apply0_bool ) {
  153|  2.94k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.94k|            }
  155|  2.94k|         }
  156|  3.06k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.94k, False: 128]
  ------------------
  157|  2.94k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.94k|         }
  159|    128|         else {
  160|    128|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    128|         }
  162|  3.06k|         (void)m( result );
  163|  3.06k|         return result;
  164|  3.06k|      }
  165|  3.06k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  3.06k|      {
   73|  3.06k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.06k|         else {
   84|  3.06k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.06k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.06k|      }
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|  3.06k|      {
   59|  3.06k|         return Rule::match( in );
   60|  3.06k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   350k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   350k|      else {
  108|   350k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   350k|         using iterator_t = typename ParseInput::iterator_t;
  111|   350k|         constexpr bool has_apply_void = 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|   350k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   350k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 350k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   350k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   350k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   350k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   350k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   350k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   350k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   350k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   350k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   350k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   350k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   350k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 350k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   350k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   350k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   350k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   350k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 348k, False: 1.41k]
  ------------------
  143|   348k|            if constexpr( has_apply_void ) {
  144|   348k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   348k|         }
  156|   350k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 348k, False: 1.49k]
  ------------------
  157|   348k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   348k|         }
  159|  1.49k|         else {
  160|  1.49k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.49k|         }
  162|   350k|         (void)m( result );
  163|   350k|         return result;
  164|   350k|      }
  165|   350k|   }
_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|   350k|      {
   73|   350k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   350k|         else {
   84|   350k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   350k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   350k|      }
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|   350k|      {
   44|   350k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   350k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   350k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   350k|      else {
  108|   350k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   350k|         using iterator_t = typename ParseInput::iterator_t;
  111|   350k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   350k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   350k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   350k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   350k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   350k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   350k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   350k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   350k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   350k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   350k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   350k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   350k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   350k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   350k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   350k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   350k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   350k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 349k, False: 1.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|   349k|            else if constexpr( has_apply0_bool ) {
  153|   349k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   349k|            }
  155|   349k|         }
  156|   350k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 349k, False: 1.15k]
  ------------------
  157|   349k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   349k|         }
  159|  1.15k|         else {
  160|  1.15k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.15k|         }
  162|   350k|         (void)m( result );
  163|   350k|         return result;
  164|   350k|      }
  165|   350k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   350k|      {
   73|   350k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   350k|         else {
   84|   350k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   350k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   350k|      }
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|   350k|      {
   59|   350k|         return Rule::match( in );
   60|   350k|      }
_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|   349k|   {
  104|   349k|      if constexpr( !Control< Rule >::enable ) {
  105|   349k|         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|   349k|   }
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|   349k|      {
   44|   349k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   349k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   349k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   349k|      else {
  108|   349k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   349k|         using iterator_t = typename ParseInput::iterator_t;
  111|   349k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   349k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   349k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   349k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   349k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   349k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   349k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   349k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   349k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   349k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   349k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   349k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   349k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   349k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   349k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   349k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   349k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   349k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 348k, False: 262]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   348k|            else if constexpr( has_apply0_bool ) {
  153|   348k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   348k|            }
  155|   348k|         }
  156|   349k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 348k, False: 262]
  ------------------
  157|   348k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   348k|         }
  159|    262|         else {
  160|    262|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    262|         }
  162|   349k|         (void)m( result );
  163|   349k|         return result;
  164|   349k|      }
  165|   349k|   }
_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|   349k|      {
   73|   349k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   349k|         else {
   84|   349k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   349k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   349k|      }
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|   349k|      {
   44|   349k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   349k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  13.6M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.6M|      else {
  108|  13.6M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.6M|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.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|  13.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|  13.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|  13.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|  13.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|  13.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|  13.6M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.6M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.6M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.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|  13.6M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.6M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.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|  13.6M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.6M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.6M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.6M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.6M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 348k, False: 13.2M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   348k|            else if constexpr( has_apply0_bool ) {
  153|   348k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   348k|            }
  155|   348k|         }
  156|  13.6M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 348k, False: 13.2M]
  ------------------
  157|   348k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   348k|         }
  159|  13.2M|         else {
  160|  13.2M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.2M|         }
  162|  13.6M|         (void)m( result );
  163|  13.6M|         return result;
  164|  13.6M|      }
  165|  13.6M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  13.6M|      {
   73|  13.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|  13.6M|         else {
   84|  13.6M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.6M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.6M|      }
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|  13.6M|      {
   59|  13.6M|         return Rule::match( in );
   60|  13.6M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  13.2M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.2M|      else {
  108|  13.2M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.2M|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.2M|         constexpr bool has_apply_void = enable_action && internal::has_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.2M|         constexpr bool has_apply_bool = enable_action && internal::has_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.2M|         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.2M|         constexpr bool has_apply0_void = enable_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.2M|         constexpr bool has_apply0_bool = enable_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.2M|         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.2M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.2M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.2M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.2M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.2M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.2M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.2M|         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.2M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.2M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.2M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.2M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.2M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.2M, False: 262]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.2M|            else if constexpr( has_apply0_bool ) {
  153|  13.2M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.2M|            }
  155|  13.2M|         }
  156|  13.2M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.2M, False: 262]
  ------------------
  157|  13.2M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.2M|         }
  159|    262|         else {
  160|    262|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    262|         }
  162|  13.2M|         (void)m( result );
  163|  13.2M|         return result;
  164|  13.2M|      }
  165|  13.2M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  13.2M|      {
   73|  13.2M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.2M|         else {
   84|  13.2M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.2M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.2M|      }
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|  13.2M|      {
   44|  13.2M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  13.2M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  13.2M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.2M|      else {
  108|  13.2M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.2M|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.2M|         constexpr bool has_apply_void = enable_action && internal::has_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.2M|         constexpr bool has_apply_bool = enable_action && internal::has_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.2M|         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.2M|         constexpr bool has_apply0_void = enable_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.2M|         constexpr bool has_apply0_bool = enable_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.2M|         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.2M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.2M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.2M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.2M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.2M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.2M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.2M|         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.2M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.2M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.2M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.2M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.2M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 192k, False: 13.0M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   192k|            else if constexpr( has_apply0_bool ) {
  153|   192k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   192k|            }
  155|   192k|         }
  156|  13.2M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 192k, False: 13.0M]
  ------------------
  157|   192k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   192k|         }
  159|  13.0M|         else {
  160|  13.0M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.0M|         }
  162|  13.2M|         (void)m( result );
  163|  13.2M|         return result;
  164|  13.2M|      }
  165|  13.2M|   }
_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|  13.2M|      {
   73|  13.2M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.2M|         else {
   84|  13.2M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.2M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.2M|      }
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|  13.2M|      {
   44|  13.2M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  13.2M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  13.2M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.2M|      else {
  108|  13.2M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.2M|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.2M|         constexpr bool has_apply_void = enable_action && internal::has_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.2M|         constexpr bool has_apply_bool = enable_action && internal::has_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.2M|         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.2M|         constexpr bool has_apply0_void = enable_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.2M|         constexpr bool has_apply0_bool = enable_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.2M|         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.2M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.2M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.2M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.2M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.2M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.2M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.2M|         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.2M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.2M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.2M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.2M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.2M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 192k, False: 13.0M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   192k|            else if constexpr( has_apply0_bool ) {
  153|   192k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   192k|            }
  155|   192k|         }
  156|  13.2M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 192k, False: 13.0M]
  ------------------
  157|   192k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   192k|         }
  159|  13.0M|         else {
  160|  13.0M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.0M|         }
  162|  13.2M|         (void)m( result );
  163|  13.2M|         return result;
  164|  13.2M|      }
  165|  13.2M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  13.2M|      {
   73|  13.2M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.2M|         else {
   84|  13.2M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.2M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.2M|      }
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|  13.2M|      {
   59|  13.2M|         return Rule::match( in );
   60|  13.2M|      }
_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|   192k|   {
  104|   192k|      if constexpr( !Control< Rule >::enable ) {
  105|   192k|         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|   192k|   }
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|   192k|      {
   44|   192k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   192k|      }
_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|   192k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   192k|      else {
  108|   192k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   192k|         using iterator_t = typename ParseInput::iterator_t;
  111|   192k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   192k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   192k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   192k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   192k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   192k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   192k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   192k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   192k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   192k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   192k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   192k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   192k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   192k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   192k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   192k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   192k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   192k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 192k, False: 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|   192k|            else if constexpr( has_apply0_bool ) {
  153|   192k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   192k|            }
  155|   192k|         }
  156|   192k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 192k, False: 86]
  ------------------
  157|   192k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   192k|         }
  159|     86|         else {
  160|     86|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     86|         }
  162|   192k|         (void)m( result );
  163|   192k|         return result;
  164|   192k|      }
  165|   192k|   }
_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|   192k|      {
   73|   192k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   192k|         else {
   84|   192k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   192k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   192k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|   192k|      {
   44|   192k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   192k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   192k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   192k|      else {
  108|   192k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   192k|         using iterator_t = typename ParseInput::iterator_t;
  111|   192k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   192k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   192k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   192k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   192k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   192k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   192k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   192k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   192k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   192k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   192k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   192k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   192k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   192k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   192k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   192k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   192k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   192k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 83.6k, False: 108k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  83.6k|            else if constexpr( has_apply0_bool ) {
  153|  83.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  83.6k|            }
  155|  83.6k|         }
  156|   192k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 83.6k, False: 108k]
  ------------------
  157|  83.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  83.6k|         }
  159|   108k|         else {
  160|   108k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   108k|         }
  162|   192k|         (void)m( result );
  163|   192k|         return result;
  164|   192k|      }
  165|   192k|   }
_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|   192k|      {
   73|   192k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   192k|         else {
   84|   192k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   192k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   192k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|   192k|      {
   44|   192k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   192k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   192k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   192k|      else {
  108|   192k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   192k|         using iterator_t = typename ParseInput::iterator_t;
  111|   192k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   192k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   192k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   192k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   192k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   192k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   192k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   192k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   192k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   192k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   192k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   192k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   192k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   192k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   192k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   192k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   192k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   192k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 83.6k, False: 108k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  83.6k|            else if constexpr( has_apply0_bool ) {
  153|  83.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  83.6k|            }
  155|  83.6k|         }
  156|   192k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 83.6k, False: 108k]
  ------------------
  157|  83.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  83.6k|         }
  159|   108k|         else {
  160|   108k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   108k|         }
  162|   192k|         (void)m( result );
  163|   192k|         return result;
  164|   192k|      }
  165|   192k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   192k|      {
   73|   192k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   192k|         else {
   84|   192k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   192k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   192k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   192k|      {
   59|   192k|         return Rule::match( in );
   60|   192k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  83.6k|   {
  104|  83.6k|      if constexpr( !Control< Rule >::enable ) {
  105|  83.6k|         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|  83.6k|   }
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|  83.6k|      {
   44|  83.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  83.6k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  83.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  83.6k|      else {
  108|  83.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  83.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  83.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|  83.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|  83.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|  83.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|  83.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|  83.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|  83.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  83.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  83.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  83.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|  83.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  83.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  83.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|  83.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  83.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  83.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  83.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  83.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 83.6k, False: 21]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  83.6k|            else if constexpr( has_apply0_bool ) {
  153|  83.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  83.6k|            }
  155|  83.6k|         }
  156|  83.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 83.6k, False: 21]
  ------------------
  157|  83.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  83.6k|         }
  159|     21|         else {
  160|     21|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     21|         }
  162|  83.6k|         (void)m( result );
  163|  83.6k|         return result;
  164|  83.6k|      }
  165|  83.6k|   }
_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|  83.6k|      {
   73|  83.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|  83.6k|         else {
   84|  83.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  83.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  83.6k|      }
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|  83.6k|      {
   44|  83.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  83.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   167k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   167k|      else {
  108|   167k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   167k|         using iterator_t = typename ParseInput::iterator_t;
  111|   167k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   167k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   167k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   167k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   167k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   167k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   167k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   167k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   167k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   167k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   167k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   167k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   167k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   167k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   167k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   167k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   167k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   167k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 167k, False: 21]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   167k|            else if constexpr( has_apply0_bool ) {
  153|   167k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   167k|            }
  155|   167k|         }
  156|   167k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 167k, False: 21]
  ------------------
  157|   167k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   167k|         }
  159|     21|         else {
  160|     21|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     21|         }
  162|   167k|         (void)m( result );
  163|   167k|         return result;
  164|   167k|      }
  165|   167k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   167k|      {
   73|   167k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   167k|         else {
   84|   167k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   167k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   167k|      }
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|   167k|      {
   59|   167k|         return Rule::match( in );
   60|   167k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   108k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   108k|      else {
  108|   108k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   108k|         using iterator_t = typename ParseInput::iterator_t;
  111|   108k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   108k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   108k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   108k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   108k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   108k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   108k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   108k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   108k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   108k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   108k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   108k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   108k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   108k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   108k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   108k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   108k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   108k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.5k, False: 75.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|  33.5k|            else if constexpr( has_apply0_bool ) {
  153|  33.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.5k|            }
  155|  33.5k|         }
  156|   108k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.5k, False: 75.0k]
  ------------------
  157|  33.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.5k|         }
  159|  75.0k|         else {
  160|  75.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  75.0k|         }
  162|   108k|         (void)m( result );
  163|   108k|         return result;
  164|   108k|      }
  165|   108k|   }
_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|   108k|      {
   73|   108k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   108k|         else {
   84|   108k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   108k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   108k|      }
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|   108k|      {
   44|   108k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   108k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_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: 40.0k, 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|  40.0k|            else if constexpr( has_apply0_bool ) {
  153|  40.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  40.0k|            }
  155|  40.0k|         }
  156|   146k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 40.0k, False: 106k]
  ------------------
  157|  40.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  40.0k|         }
  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_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   146k|      {
   59|   146k|         return Rule::match( in );
   60|   146k|      }
_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|  33.5k|   {
  104|  33.5k|      if constexpr( !Control< Rule >::enable ) {
  105|  33.5k|         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|  33.5k|   }
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|  33.5k|      {
   44|  33.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.5k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  33.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  33.5k|      else {
  108|  33.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.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|  33.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|  33.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|  33.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|  33.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|  33.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|  33.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.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|  33.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.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|  33.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  33.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.5k, 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.5k|            else if constexpr( has_apply0_bool ) {
  153|  33.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.5k|            }
  155|  33.5k|         }
  156|  33.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.5k, False: 0]
  ------------------
  157|  33.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.5k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  33.5k|         (void)m( result );
  163|  33.5k|         return result;
  164|  33.5k|      }
  165|  33.5k|   }
_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|  33.5k|      {
   73|  33.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|  33.5k|         else {
   84|  33.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.5k|      }
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|  33.5k|      {
   44|  33.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  75.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  75.0k|      else {
  108|  75.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  75.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  75.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|  75.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|  75.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|  75.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|  75.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|  75.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|  75.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  75.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  75.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  75.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|  75.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  75.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  75.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|  75.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  75.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  75.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  75.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  75.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 72.2k, False: 2.79k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  72.2k|            else if constexpr( has_apply0_bool ) {
  153|  72.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  72.2k|            }
  155|  72.2k|         }
  156|  75.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 72.2k, False: 2.79k]
  ------------------
  157|  72.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  72.2k|         }
  159|  2.79k|         else {
  160|  2.79k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.79k|         }
  162|  75.0k|         (void)m( result );
  163|  75.0k|         return result;
  164|  75.0k|      }
  165|  75.0k|   }
_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|  75.0k|      {
   73|  75.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|  75.0k|         else {
   84|  75.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  75.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  75.0k|      }
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|  75.0k|      {
   59|  75.0k|         return Rule::match( in );
   60|  75.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.79k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.79k|      else {
  108|  2.79k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.79k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.79k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.79k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.79k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.79k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.79k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.79k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.79k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.79k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.79k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.79k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.73k, 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|  2.73k|            else if constexpr( has_apply0_bool ) {
  153|  2.73k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.73k|            }
  155|  2.73k|         }
  156|  2.79k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.73k, False: 65]
  ------------------
  157|  2.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.73k|         }
  159|     65|         else {
  160|     65|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     65|         }
  162|  2.79k|         (void)m( result );
  163|  2.79k|         return result;
  164|  2.79k|      }
  165|  2.79k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  2.79k|      {
   73|  2.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|  2.79k|         else {
   84|  2.79k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.79k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.79k|      }
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|  2.79k|      {
   59|  2.79k|         return Rule::match( in );
   60|  2.79k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  13.0M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.0M|      else {
  108|  13.0M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.0M|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.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|  13.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|  13.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|  13.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|  13.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|  13.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|  13.0M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.0M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.0M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.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|  13.0M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.0M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.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|  13.0M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.0M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.0M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.0M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.0M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.0M, 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|  13.0M|            else if constexpr( has_apply0_bool ) {
  153|  13.0M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.0M|            }
  155|  13.0M|         }
  156|  13.0M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.0M, False: 176]
  ------------------
  157|  13.0M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.0M|         }
  159|    176|         else {
  160|    176|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    176|         }
  162|  13.0M|         (void)m( result );
  163|  13.0M|         return result;
  164|  13.0M|      }
  165|  13.0M|   }
_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|  13.0M|      {
   73|  13.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|  13.0M|         else {
   84|  13.0M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.0M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.0M|      }
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|  13.0M|      {
   59|  13.0M|         return Rule::match( in );
   60|  13.0M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14hash_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  43.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  43.4k|      else {
  108|  43.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  43.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  43.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|  43.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|  43.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|  43.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|  43.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  43.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  43.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  43.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.37k, False: 38.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|  5.37k|            else if constexpr( has_apply0_bool ) {
  153|  5.37k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.37k|            }
  155|  5.37k|         }
  156|  43.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.37k, False: 38.0k]
  ------------------
  157|  5.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.37k|         }
  159|  38.0k|         else {
  160|  38.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  38.0k|         }
  162|  43.4k|         (void)m( result );
  163|  43.4k|         return result;
  164|  43.4k|      }
  165|  43.4k|   }
_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|  43.4k|      {
   73|  43.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|  43.4k|         else {
   84|  43.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  43.4k|      {
   44|  43.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.4k|      }
_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|  43.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  43.4k|      else {
  108|  43.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  43.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  43.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|  43.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|  43.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|  43.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|  43.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  43.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  43.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  43.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.37k, False: 38.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|  5.37k|            else if constexpr( has_apply0_bool ) {
  153|  5.37k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.37k|            }
  155|  5.37k|         }
  156|  43.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.37k, False: 38.0k]
  ------------------
  157|  5.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.37k|         }
  159|  38.0k|         else {
  160|  38.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  38.0k|         }
  162|  43.4k|         (void)m( result );
  163|  43.4k|         return result;
  164|  43.4k|      }
  165|  43.4k|   }
_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|  43.4k|      {
   73|  43.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|  43.4k|         else {
   84|  43.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  43.4k|      {
   44|  43.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  43.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8str_hashELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  43.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  43.4k|      else {
  108|  43.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  43.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  43.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [True: 0, Folded]
  ------------------
  112|  43.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  43.4k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 43.4k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  43.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|  43.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|  43.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|  43.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  43.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  43.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  43.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  43.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  43.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  43.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  43.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 43.4k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  43.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  43.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  43.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  43.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.07k, False: 37.3k]
  ------------------
  143|  6.07k|            if constexpr( has_apply_void ) {
  144|  6.07k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.07k|         }
  156|  43.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.06k, False: 37.3k]
  ------------------
  157|  6.06k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.06k|         }
  159|  37.3k|         else {
  160|  37.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  37.3k|         }
  162|  43.4k|         (void)m( result );
  163|  43.4k|         return result;
  164|  43.4k|      }
  165|  43.4k|   }
_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|  43.4k|      {
   73|  43.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|  43.4k|         else {
   84|  43.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  43.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  43.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  43.4k|      {
   59|  43.4k|         return Rule::match( in );
   60|  43.4k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  38.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.9k|      else {
  108|  38.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.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|  38.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|  38.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|  38.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|  38.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  38.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.0k, 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|  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|  38.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.0k, False: 3.89k]
  ------------------
  157|  35.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.0k|         }
  159|  3.89k|         else {
  160|  3.89k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.89k|         }
  162|  38.9k|         (void)m( result );
  163|  38.9k|         return result;
  164|  38.9k|      }
  165|  38.9k|   }
_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|  38.9k|      {
   73|  38.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|  38.9k|         else {
   84|  38.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  38.9k|      {
   44|  38.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  38.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  38.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.9k|      else {
  108|  38.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.9k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  38.9k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  38.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|  38.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|  38.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|  38.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|  38.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.9k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.9k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  38.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.0k, 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|  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|  38.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.0k, False: 3.89k]
  ------------------
  157|  35.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.0k|         }
  159|  3.89k|         else {
  160|  3.89k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.89k|         }
  162|  38.9k|         (void)m( result );
  163|  38.9k|         return result;
  164|  38.9k|      }
  165|  38.9k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  38.9k|      {
   73|  38.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|  38.9k|         else {
   84|  38.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.9k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  38.9k|      {
   59|  38.9k|         return Rule::match( in );
   60|  38.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  49.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  49.2k|      else {
  108|  49.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  49.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  49.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|  49.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|  49.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|  49.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|  49.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|  49.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|  49.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  49.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  49.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  49.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|  49.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  49.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  49.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|  49.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  49.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  49.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  49.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  49.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.10k, False: 44.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|  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|  49.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.10k, False: 44.1k]
  ------------------
  157|  5.10k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.10k|         }
  159|  44.1k|         else {
  160|  44.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  44.1k|         }
  162|  49.2k|         (void)m( result );
  163|  49.2k|         return result;
  164|  49.2k|      }
  165|  49.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  49.2k|      {
   73|  49.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|  49.2k|         else {
   84|  49.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  49.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  49.2k|      }
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|  49.2k|      {
   59|  49.2k|         return Rule::match( in );
   60|  49.2k|      }
_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|  6.05k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.05k|      else {
  108|  6.05k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.05k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.05k|         constexpr bool has_apply_void = enable_action && internal::has_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.05k|         constexpr bool has_apply_bool = enable_action && internal::has_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.05k|         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.05k|         constexpr bool has_apply0_void = enable_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.05k|         constexpr bool has_apply0_bool = enable_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.05k|         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.05k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.05k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.05k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.05k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.05k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.05k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.05k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.05k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.05k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.05k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.05k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.05k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.37k, False: 673]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.37k|            else if constexpr( has_apply0_bool ) {
  153|  5.37k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.37k|            }
  155|  5.37k|         }
  156|  6.05k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.37k, False: 673]
  ------------------
  157|  5.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.37k|         }
  159|    673|         else {
  160|    673|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    673|         }
  162|  6.05k|         (void)m( result );
  163|  6.05k|         return result;
  164|  6.05k|      }
  165|  6.05k|   }
_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|  6.05k|      {
   73|  6.05k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.05k|         else {
   84|  6.05k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.05k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.05k|      }
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|  6.05k|      {
   44|  6.05k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.05k|      }
_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|  6.05k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.05k|      else {
  108|  6.05k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.05k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.05k|         constexpr bool has_apply_void = enable_action && internal::has_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.05k|         constexpr bool has_apply_bool = enable_action && internal::has_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.05k|         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.05k|         constexpr bool has_apply0_void = enable_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.05k|         constexpr bool has_apply0_bool = enable_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.05k|         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.05k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.05k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.05k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.05k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.05k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.05k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.05k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.05k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.05k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.05k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.05k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.05k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.37k, 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|  4.37k|            else if constexpr( has_apply0_bool ) {
  153|  4.37k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.37k|            }
  155|  4.37k|         }
  156|  6.05k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.37k, False: 1.67k]
  ------------------
  157|  4.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.37k|         }
  159|  1.67k|         else {
  160|  1.67k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.67k|         }
  162|  6.05k|         (void)m( result );
  163|  6.05k|         return result;
  164|  6.05k|      }
  165|  6.05k|   }
_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|  6.05k|      {
   73|  6.05k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.05k|         else {
   84|  6.05k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.05k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.05k|      }
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|  6.05k|      {
   44|  6.05k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.05k|      }
_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|  6.05k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.05k|      else {
  108|  6.05k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.05k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.05k|         constexpr bool has_apply_void = enable_action && internal::has_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.05k|         constexpr bool has_apply_bool = enable_action && internal::has_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.05k|         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.05k|         constexpr bool has_apply0_void = enable_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.05k|         constexpr bool has_apply0_bool = enable_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.05k|         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.05k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.05k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.05k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.05k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.05k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.05k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.05k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.05k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.05k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.05k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.05k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.05k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.05k, 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.05k|            else if constexpr( has_apply0_bool ) {
  153|  6.05k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.05k|            }
  155|  6.05k|         }
  156|  6.05k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.05k, False: 0]
  ------------------
  157|  6.05k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.05k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.05k|         (void)m( result );
  163|  6.05k|         return result;
  164|  6.05k|      }
  165|  6.05k|   }
_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|  6.05k|      {
   73|  6.05k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.05k|         else {
   84|  6.05k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.05k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.05k|      }
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|  6.05k|      {
   44|  6.05k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.05k|      }
_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|  6.05k|   {
  104|  6.05k|      if constexpr( !Control< Rule >::enable ) {
  105|  6.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|  6.05k|   }
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|  6.05k|      {
   44|  6.05k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.05k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.05k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.05k|      else {
  108|  6.05k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.05k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.05k|         constexpr bool has_apply_void = 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.05k|         constexpr bool has_apply_bool = enable_action && internal::has_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.05k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 6.05k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.05k|         constexpr bool has_apply0_void = enable_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.05k|         constexpr bool has_apply0_bool = enable_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.05k|         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.05k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.05k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.05k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.05k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.05k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.05k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.05k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.05k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 6.05k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.05k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.05k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.05k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.05k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.61k, False: 2.43k]
  ------------------
  143|  3.61k|            if constexpr( has_apply_void ) {
  144|  3.61k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.61k|         }
  156|  6.05k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.61k, False: 2.43k]
  ------------------
  157|  3.61k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.61k|         }
  159|  2.43k|         else {
  160|  2.43k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.43k|         }
  162|  6.05k|         (void)m( result );
  163|  6.05k|         return result;
  164|  6.05k|      }
  165|  6.05k|   }
_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|  6.05k|      {
   73|  6.05k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.05k|         else {
   84|  6.05k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.05k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.05k|      }
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|  6.05k|      {
   44|  6.05k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.05k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.05k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.05k|      else {
  108|  6.05k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.05k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.05k|         constexpr bool has_apply_void = enable_action && internal::has_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.05k|         constexpr bool has_apply_bool = enable_action && internal::has_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.05k|         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.05k|         constexpr bool has_apply0_void = enable_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.05k|         constexpr bool has_apply0_bool = enable_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.05k|         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.05k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.05k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.05k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.05k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.05k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.05k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.05k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.05k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.05k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.05k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.05k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.05k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 354, False: 5.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|    354|            else if constexpr( has_apply0_bool ) {
  153|    354|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    354|            }
  155|    354|         }
  156|  6.05k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 354, False: 5.69k]
  ------------------
  157|    354|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    354|         }
  159|  5.69k|         else {
  160|  5.69k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.69k|         }
  162|  6.05k|         (void)m( result );
  163|  6.05k|         return result;
  164|  6.05k|      }
  165|  6.05k|   }
_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|  6.05k|      {
   73|  6.05k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.05k|         else {
   84|  6.05k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.05k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.05k|      }
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|  6.05k|      {
   59|  6.05k|         return Rule::match( in );
   60|  6.05k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.69k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.69k|      else {
  108|  5.69k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.69k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.69k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.69k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.69k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.69k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.69k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.69k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.69k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.69k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.69k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.69k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.32k, False: 3.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.32k|            else if constexpr( has_apply0_bool ) {
  153|  2.32k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.32k|            }
  155|  2.32k|         }
  156|  5.69k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.32k, False: 3.36k]
  ------------------
  157|  2.32k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.32k|         }
  159|  3.36k|         else {
  160|  3.36k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.36k|         }
  162|  5.69k|         (void)m( result );
  163|  5.69k|         return result;
  164|  5.69k|      }
  165|  5.69k|   }
_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|  5.69k|      {
   73|  5.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|  5.69k|         else {
   84|  5.69k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.69k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.69k|      }
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|  5.69k|      {
   59|  5.69k|         return Rule::match( in );
   60|  5.69k|      }
_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.36k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.36k|      else {
  108|  3.36k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.36k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.36k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.36k|         constexpr bool has_apply_bool = enable_action && internal::has_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.36k|         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.36k|         constexpr bool has_apply0_void = enable_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.36k|         constexpr bool has_apply0_bool = enable_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.36k|         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.36k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.36k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.36k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.36k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.36k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.36k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.36k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.36k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.36k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.36k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.36k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.36k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 337, False: 3.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|    337|            else if constexpr( has_apply0_bool ) {
  153|    337|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    337|            }
  155|    337|         }
  156|  3.36k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 337, False: 3.03k]
  ------------------
  157|    337|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    337|         }
  159|  3.03k|         else {
  160|  3.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.03k|         }
  162|  3.36k|         (void)m( result );
  163|  3.36k|         return result;
  164|  3.36k|      }
  165|  3.36k|   }
_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.36k|      {
   73|  3.36k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.36k|         else {
   84|  3.36k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.36k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.36k|      }
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.36k|      {
   59|  3.36k|         return Rule::match( in );
   60|  3.36k|      }
_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.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.03k|      else {
  108|  3.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.03k|         constexpr bool has_apply_void = enable_action && internal::has_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.03k|         constexpr bool has_apply_bool = enable_action && internal::has_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.03k|         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.03k|         constexpr bool has_apply0_void = enable_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.03k|         constexpr bool has_apply0_bool = enable_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.03k|         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.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 187, 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|    187|            else if constexpr( has_apply0_bool ) {
  153|    187|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    187|            }
  155|    187|         }
  156|  3.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 187, False: 2.84k]
  ------------------
  157|    187|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    187|         }
  159|  2.84k|         else {
  160|  2.84k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.84k|         }
  162|  3.03k|         (void)m( result );
  163|  3.03k|         return result;
  164|  3.03k|      }
  165|  3.03k|   }
_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.03k|      {
   73|  3.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.03k|         else {
   84|  3.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.03k|      }
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.03k|      {
   59|  3.03k|         return Rule::match( in );
   60|  3.03k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_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: 120, False: 2.72k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    120|            else if constexpr( has_apply0_bool ) {
  153|    120|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    120|            }
  155|    120|         }
  156|  2.84k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 120, False: 2.72k]
  ------------------
  157|    120|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    120|         }
  159|  2.72k|         else {
  160|  2.72k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.72k|         }
  162|  2.84k|         (void)m( result );
  163|  2.84k|         return result;
  164|  2.84k|      }
  165|  2.84k|   }
_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|  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_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|  2.84k|      {
   59|  2.84k|         return Rule::match( in );
   60|  2.84k|      }
_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.72k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.72k|      else {
  108|  2.72k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.72k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.72k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.72k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.72k|         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.72k|         constexpr bool has_apply0_void = enable_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.72k|         constexpr bool has_apply0_bool = enable_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.72k|         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.72k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.72k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.72k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.72k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.72k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.72k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.72k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.72k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.72k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.72k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.72k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.72k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 287, False: 2.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|    287|            else if constexpr( has_apply0_bool ) {
  153|    287|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    287|            }
  155|    287|         }
  156|  2.72k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 287, False: 2.43k]
  ------------------
  157|    287|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    287|         }
  159|  2.43k|         else {
  160|  2.43k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.43k|         }
  162|  2.72k|         (void)m( result );
  163|  2.72k|         return result;
  164|  2.72k|      }
  165|  2.72k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.72k|      {
   73|  2.72k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.72k|         else {
   84|  2.72k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.72k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.72k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.72k|      {
   59|  2.72k|         return Rule::match( in );
   60|  2.72k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.05k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.05k|      else {
  108|  6.05k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.05k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.05k|         constexpr bool has_apply_void = enable_action && internal::has_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.05k|         constexpr bool has_apply_bool = enable_action && internal::has_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.05k|         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.05k|         constexpr bool has_apply0_void = enable_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.05k|         constexpr bool has_apply0_bool = enable_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.05k|         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.05k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.05k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.05k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.05k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.05k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.05k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.05k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.05k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.05k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.05k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.05k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.05k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.58k, False: 1.46k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.58k|            else if constexpr( has_apply0_bool ) {
  153|  4.58k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.58k|            }
  155|  4.58k|         }
  156|  6.05k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.58k, False: 1.46k]
  ------------------
  157|  4.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.58k|         }
  159|  1.46k|         else {
  160|  1.46k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.46k|         }
  162|  6.05k|         (void)m( result );
  163|  6.05k|         return result;
  164|  6.05k|      }
  165|  6.05k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.05k|      {
   73|  6.05k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.05k|         else {
   84|  6.05k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.05k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.05k|      }
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|  6.05k|      {
   59|  6.05k|         return Rule::match( in );
   60|  6.05k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  9.09k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.09k|      else {
  108|  9.09k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.09k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.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|  9.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|  9.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|  9.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|  9.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|  9.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|  9.09k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.09k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.09k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.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|  9.09k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.09k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.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|  9.09k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.09k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.09k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.09k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.09k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.09k, 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|  9.09k|            else if constexpr( has_apply0_bool ) {
  153|  9.09k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.09k|            }
  155|  9.09k|         }
  156|  9.09k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.09k, False: 0]
  ------------------
  157|  9.09k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.09k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  9.09k|         (void)m( result );
  163|  9.09k|         return result;
  164|  9.09k|      }
  165|  9.09k|   }
_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|  9.09k|      {
   73|  9.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|  9.09k|         else {
   84|  9.09k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.09k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.09k|      }
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|  9.09k|      {
   44|  9.09k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.09k|      }
_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|  4.58k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.58k|      else {
  108|  4.58k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.58k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.58k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.58k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.58k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.58k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.58k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.58k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.58k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.58k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.58k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.58k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.51k, 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|  4.51k|            else if constexpr( has_apply0_bool ) {
  153|  4.51k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.51k|            }
  155|  4.51k|         }
  156|  4.58k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.51k, False: 70]
  ------------------
  157|  4.51k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.51k|         }
  159|     70|         else {
  160|     70|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     70|         }
  162|  4.58k|         (void)m( result );
  163|  4.58k|         return result;
  164|  4.58k|      }
  165|  4.58k|   }
_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|  4.58k|      {
   73|  4.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|  4.58k|         else {
   84|  4.58k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.58k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.58k|      }
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|  4.58k|      {
   44|  4.58k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.58k|      }
_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|  4.52k|   {
  104|  4.52k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.52k|         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.52k|   }
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|  4.52k|      {
   44|  4.52k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.52k|      }
_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|  29.2k|   {
  104|  29.2k|      if constexpr( !Control< Rule >::enable ) {
  105|  29.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|  29.2k|   }
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|  29.2k|      {
   44|  29.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.51k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.51k|      else {
  108|  4.51k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.51k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.51k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.51k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.51k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.51k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.51k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.51k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.51k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.51k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.51k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.51k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.37k, False: 137]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.37k|            else if constexpr( has_apply0_bool ) {
  153|  4.37k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.37k|            }
  155|  4.37k|         }
  156|  4.51k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.37k, False: 137]
  ------------------
  157|  4.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.37k|         }
  159|    137|         else {
  160|    137|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    137|         }
  162|  4.51k|         (void)m( result );
  163|  4.51k|         return result;
  164|  4.51k|      }
  165|  4.51k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  4.51k|      {
   73|  4.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|  4.51k|         else {
   84|  4.51k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.51k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.51k|      }
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|  4.51k|      {
   59|  4.51k|         return Rule::match( in );
   60|  4.51k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  31.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  31.6k|      else {
  108|  31.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.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): [True: 0, Folded]
  ------------------
  112|  31.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|  31.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 31.6k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  31.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|  31.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|  31.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|  31.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.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|  31.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.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|  31.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 31.6k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  31.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.2k, False: 1.32k]
  ------------------
  143|  30.2k|            if constexpr( has_apply_void ) {
  144|  30.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|  30.2k|         }
  156|  31.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.2k, False: 1.39k]
  ------------------
  157|  30.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.2k|         }
  159|  1.39k|         else {
  160|  1.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.39k|         }
  162|  31.6k|         (void)m( result );
  163|  31.6k|         return result;
  164|  31.6k|      }
  165|  31.6k|   }
_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|  31.6k|      {
   73|  31.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|  31.6k|         else {
   84|  31.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  31.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  31.6k|      }
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|  31.6k|      {
   44|  31.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  31.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  31.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  31.6k|      else {
  108|  31.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.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|  31.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|  31.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|  31.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|  31.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|  31.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|  31.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.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|  31.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.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|  31.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  31.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.5k, False: 1.06k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.5k|            else if constexpr( has_apply0_bool ) {
  153|  30.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.5k|            }
  155|  30.5k|         }
  156|  31.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.5k, False: 1.06k]
  ------------------
  157|  30.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.5k|         }
  159|  1.06k|         else {
  160|  1.06k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.06k|         }
  162|  31.6k|         (void)m( result );
  163|  31.6k|         return result;
  164|  31.6k|      }
  165|  31.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  31.6k|      {
   73|  31.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|  31.6k|         else {
   84|  31.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  31.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  31.6k|      }
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|  31.6k|      {
   59|  31.6k|         return Rule::match( in );
   60|  31.6k|      }
_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|  30.5k|   {
  104|  30.5k|      if constexpr( !Control< Rule >::enable ) {
  105|  30.5k|         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|  30.5k|   }
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|  30.5k|      {
   44|  30.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.5k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  30.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  30.5k|      else {
  108|  30.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.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|  30.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|  30.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|  30.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|  30.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|  30.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|  30.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.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|  30.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.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|  30.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  30.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.2k, False: 266]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.2k|            else if constexpr( has_apply0_bool ) {
  153|  30.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.2k|            }
  155|  30.2k|         }
  156|  30.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.2k, False: 266]
  ------------------
  157|  30.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.2k|         }
  159|    266|         else {
  160|    266|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    266|         }
  162|  30.5k|         (void)m( result );
  163|  30.5k|         return result;
  164|  30.5k|      }
  165|  30.5k|   }
_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|  30.5k|      {
   73|  30.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|  30.5k|         else {
   84|  30.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.5k|      }
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|  30.5k|      {
   44|  30.5k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  13.4M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.4M|      else {
  108|  13.4M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.4M|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.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|  13.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|  13.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|  13.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|  13.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|  13.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|  13.4M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.4M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.4M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.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|  13.4M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.4M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.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|  13.4M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.4M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.4M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.4M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.4M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.2k, False: 13.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|  30.2k|            else if constexpr( has_apply0_bool ) {
  153|  30.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.2k|            }
  155|  30.2k|         }
  156|  13.4M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.2k, False: 13.4M]
  ------------------
  157|  30.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.2k|         }
  159|  13.4M|         else {
  160|  13.4M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.4M|         }
  162|  13.4M|         (void)m( result );
  163|  13.4M|         return result;
  164|  13.4M|      }
  165|  13.4M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  13.4M|      {
   73|  13.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|  13.4M|         else {
   84|  13.4M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.4M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.4M|      }
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|  13.4M|      {
   59|  13.4M|         return Rule::match( in );
   60|  13.4M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  13.4M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.4M|      else {
  108|  13.4M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.4M|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.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|  13.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|  13.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|  13.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|  13.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|  13.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|  13.4M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.4M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.4M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.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|  13.4M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.4M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.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|  13.4M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.4M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.4M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.4M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.4M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.4M, False: 266]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.4M|            else if constexpr( has_apply0_bool ) {
  153|  13.4M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.4M|            }
  155|  13.4M|         }
  156|  13.4M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.4M, False: 266]
  ------------------
  157|  13.4M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.4M|         }
  159|    266|         else {
  160|    266|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    266|         }
  162|  13.4M|         (void)m( result );
  163|  13.4M|         return result;
  164|  13.4M|      }
  165|  13.4M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  13.4M|      {
   73|  13.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|  13.4M|         else {
   84|  13.4M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.4M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.4M|      }
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|  13.4M|      {
   44|  13.4M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  13.4M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  13.4M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.4M|      else {
  108|  13.4M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.4M|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.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|  13.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|  13.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|  13.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|  13.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|  13.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|  13.4M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.4M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.4M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.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|  13.4M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.4M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.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|  13.4M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.4M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.4M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.4M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.4M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 70.5k, False: 13.3M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  70.5k|            else if constexpr( has_apply0_bool ) {
  153|  70.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  70.5k|            }
  155|  70.5k|         }
  156|  13.4M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 70.5k, False: 13.3M]
  ------------------
  157|  70.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  70.5k|         }
  159|  13.3M|         else {
  160|  13.3M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.3M|         }
  162|  13.4M|         (void)m( result );
  163|  13.4M|         return result;
  164|  13.4M|      }
  165|  13.4M|   }
_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|  13.4M|      {
   73|  13.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|  13.4M|         else {
   84|  13.4M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.4M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.4M|      }
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|  13.4M|      {
   44|  13.4M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  13.4M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  13.4M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.4M|      else {
  108|  13.4M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.4M|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.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|  13.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|  13.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|  13.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|  13.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|  13.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|  13.4M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.4M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.4M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.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|  13.4M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.4M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.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|  13.4M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.4M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.4M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.4M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.4M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 70.6k, False: 13.3M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  70.6k|            else if constexpr( has_apply0_bool ) {
  153|  70.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  70.6k|            }
  155|  70.6k|         }
  156|  13.4M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 70.6k, False: 13.3M]
  ------------------
  157|  70.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  70.6k|         }
  159|  13.3M|         else {
  160|  13.3M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.3M|         }
  162|  13.4M|         (void)m( result );
  163|  13.4M|         return result;
  164|  13.4M|      }
  165|  13.4M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  13.4M|      {
   73|  13.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|  13.4M|         else {
   84|  13.4M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.4M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.4M|      }
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|  13.4M|      {
   59|  13.4M|         return Rule::match( in );
   60|  13.4M|      }
_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|  70.6k|   {
  104|  70.6k|      if constexpr( !Control< Rule >::enable ) {
  105|  70.6k|         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|  70.6k|   }
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|  70.6k|      {
   44|  70.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  70.6k|      }
_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|  70.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  70.6k|      else {
  108|  70.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  70.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  70.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|  70.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|  70.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|  70.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|  70.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|  70.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|  70.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  70.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  70.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  70.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|  70.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  70.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  70.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|  70.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  70.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  70.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  70.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  70.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 70.5k, False: 89]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  70.5k|            else if constexpr( has_apply0_bool ) {
  153|  70.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  70.5k|            }
  155|  70.5k|         }
  156|  70.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 70.5k, False: 89]
  ------------------
  157|  70.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  70.5k|         }
  159|     89|         else {
  160|     89|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     89|         }
  162|  70.6k|         (void)m( result );
  163|  70.6k|         return result;
  164|  70.6k|      }
  165|  70.6k|   }
_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|  70.6k|      {
   73|  70.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|  70.6k|         else {
   84|  70.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  70.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  70.6k|      }
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|  70.6k|      {
   44|  70.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  70.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  70.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  70.6k|      else {
  108|  70.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  70.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  70.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|  70.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|  70.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|  70.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|  70.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|  70.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|  70.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  70.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  70.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  70.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|  70.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  70.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  70.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|  70.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  70.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  70.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  70.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  70.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 18.1k, False: 52.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|  18.1k|            else if constexpr( has_apply0_bool ) {
  153|  18.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  18.1k|            }
  155|  18.1k|         }
  156|  70.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 18.1k, False: 52.4k]
  ------------------
  157|  18.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  18.1k|         }
  159|  52.4k|         else {
  160|  52.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  52.4k|         }
  162|  70.6k|         (void)m( result );
  163|  70.6k|         return result;
  164|  70.6k|      }
  165|  70.6k|   }
_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|  70.6k|      {
   73|  70.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|  70.6k|         else {
   84|  70.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  70.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  70.6k|      }
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|  70.6k|      {
   44|  70.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  70.6k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  70.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  70.6k|      else {
  108|  70.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  70.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  70.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|  70.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|  70.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|  70.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|  70.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|  70.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|  70.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  70.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  70.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  70.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|  70.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  70.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  70.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|  70.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  70.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  70.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  70.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  70.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 18.2k, False: 52.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|  18.2k|            else if constexpr( has_apply0_bool ) {
  153|  18.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  18.2k|            }
  155|  18.2k|         }
  156|  70.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 18.2k, False: 52.4k]
  ------------------
  157|  18.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  18.2k|         }
  159|  52.4k|         else {
  160|  52.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  52.4k|         }
  162|  70.6k|         (void)m( result );
  163|  70.6k|         return result;
  164|  70.6k|      }
  165|  70.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  70.6k|      {
   73|  70.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|  70.6k|         else {
   84|  70.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  70.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  70.6k|      }
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|  70.6k|      {
   59|  70.6k|         return Rule::match( in );
   60|  70.6k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  18.2k|   {
  104|  18.2k|      if constexpr( !Control< Rule >::enable ) {
  105|  18.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|  18.2k|   }
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|  18.2k|      {
   44|  18.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  18.2k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  18.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  18.2k|      else {
  108|  18.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  18.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  18.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|  18.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|  18.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|  18.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|  18.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|  18.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|  18.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  18.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  18.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  18.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|  18.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  18.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  18.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|  18.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  18.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  18.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  18.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  18.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 18.1k, False: 36]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  18.1k|            else if constexpr( has_apply0_bool ) {
  153|  18.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  18.1k|            }
  155|  18.1k|         }
  156|  18.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 18.1k, False: 36]
  ------------------
  157|  18.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  18.1k|         }
  159|     36|         else {
  160|     36|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     36|         }
  162|  18.2k|         (void)m( result );
  163|  18.2k|         return result;
  164|  18.2k|      }
  165|  18.2k|   }
_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|  18.2k|      {
   73|  18.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|  18.2k|         else {
   84|  18.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  18.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  18.2k|      }
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|  18.2k|      {
   44|  18.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  18.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  36.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  36.4k|      else {
  108|  36.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  36.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  36.4k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  36.4k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  36.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|  36.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|  36.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|  36.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|  36.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  36.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  36.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  36.4k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  36.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  36.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  36.4k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  36.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  36.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  36.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  36.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  36.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 36.3k, False: 36]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  36.3k|            else if constexpr( has_apply0_bool ) {
  153|  36.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  36.3k|            }
  155|  36.3k|         }
  156|  36.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 36.3k, False: 36]
  ------------------
  157|  36.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  36.3k|         }
  159|     36|         else {
  160|     36|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     36|         }
  162|  36.4k|         (void)m( result );
  163|  36.4k|         return result;
  164|  36.4k|      }
  165|  36.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  36.4k|      {
   73|  36.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|  36.4k|         else {
   84|  36.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  36.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  36.4k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  36.4k|      {
   59|  36.4k|         return Rule::match( in );
   60|  36.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  52.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  52.4k|      else {
  108|  52.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  52.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  52.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|  52.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|  52.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|  52.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|  52.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|  52.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|  52.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  52.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  52.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  52.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|  52.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  52.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  52.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|  52.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  52.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  52.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  52.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  52.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 27.0k, False: 25.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|  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|  52.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 27.0k, False: 25.3k]
  ------------------
  157|  27.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  27.0k|         }
  159|  25.3k|         else {
  160|  25.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  25.3k|         }
  162|  52.4k|         (void)m( result );
  163|  52.4k|         return result;
  164|  52.4k|      }
  165|  52.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|  52.4k|      {
   73|  52.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|  52.4k|         else {
   84|  52.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  52.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  52.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|  52.4k|      {
   44|  52.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  52.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  83.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  83.2k|      else {
  108|  83.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  83.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  83.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|  83.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|  83.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|  83.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|  83.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|  83.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|  83.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  83.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  83.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  83.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|  83.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  83.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  83.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|  83.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  83.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  83.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  83.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  83.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.2k, False: 49.9k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.2k|            else if constexpr( has_apply0_bool ) {
  153|  33.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.2k|            }
  155|  33.2k|         }
  156|  83.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.2k, False: 49.9k]
  ------------------
  157|  33.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.2k|         }
  159|  49.9k|         else {
  160|  49.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  49.9k|         }
  162|  83.2k|         (void)m( result );
  163|  83.2k|         return result;
  164|  83.2k|      }
  165|  83.2k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  83.2k|      {
   73|  83.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|  83.2k|         else {
   84|  83.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  83.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  83.2k|      }
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|  83.2k|      {
   59|  83.2k|         return Rule::match( in );
   60|  83.2k|      }
_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|  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_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|  27.0k|      {
   44|  27.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.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|  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: 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|  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: 0]
  ------------------
  157|  27.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  27.0k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  27.0k|         (void)m( result );
  163|  27.0k|         return result;
  164|  27.0k|      }
  165|  27.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|  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_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|  27.0k|      {
   44|  27.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  25.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  25.3k|      else {
  108|  25.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  25.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  25.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  25.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  25.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|  25.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|  25.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|  25.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|  25.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  25.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  25.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  25.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  25.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  25.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  25.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  25.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  25.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  25.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  25.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 24.9k, False: 417]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.9k|            else if constexpr( has_apply0_bool ) {
  153|  24.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  24.9k|            }
  155|  24.9k|         }
  156|  25.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 24.9k, False: 417]
  ------------------
  157|  24.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  24.9k|         }
  159|    417|         else {
  160|    417|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    417|         }
  162|  25.3k|         (void)m( result );
  163|  25.3k|         return result;
  164|  25.3k|      }
  165|  25.3k|   }
_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|  25.3k|      {
   73|  25.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|  25.3k|         else {
   84|  25.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  25.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  25.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  25.3k|      {
   59|  25.3k|         return Rule::match( in );
   60|  25.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    417|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    417|      else {
  108|    417|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    417|         using iterator_t = typename ParseInput::iterator_t;
  111|    417|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    417|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    417|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    417|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    417|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    417|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    417|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    417|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    417|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    417|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    417|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    417|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    417|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    417|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    417|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    417|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    417|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    417|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 364, False: 53]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    364|            else if constexpr( has_apply0_bool ) {
  153|    364|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    364|            }
  155|    364|         }
  156|    417|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 364, False: 53]
  ------------------
  157|    364|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    364|         }
  159|     53|         else {
  160|     53|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     53|         }
  162|    417|         (void)m( result );
  163|    417|         return result;
  164|    417|      }
  165|    417|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    417|      {
   73|    417|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    417|         else {
   84|    417|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    417|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    417|      }
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|    417|      {
   59|    417|         return Rule::match( in );
   60|    417|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  13.3M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  13.3M|      else {
  108|  13.3M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  13.3M|         using iterator_t = typename ParseInput::iterator_t;
  111|  13.3M|         constexpr bool has_apply_void = enable_action && internal::has_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.3M|         constexpr bool has_apply_bool = enable_action && internal::has_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.3M|         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.3M|         constexpr bool has_apply0_void = enable_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.3M|         constexpr bool has_apply0_bool = enable_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.3M|         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.3M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  13.3M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  13.3M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  13.3M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.3M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  13.3M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  13.3M|         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.3M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  13.3M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  13.3M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  13.3M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  13.3M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 13.3M, False: 177]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.3M|            else if constexpr( has_apply0_bool ) {
  153|  13.3M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  13.3M|            }
  155|  13.3M|         }
  156|  13.3M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 13.3M, False: 177]
  ------------------
  157|  13.3M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  13.3M|         }
  159|    177|         else {
  160|    177|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    177|         }
  162|  13.3M|         (void)m( result );
  163|  13.3M|         return result;
  164|  13.3M|      }
  165|  13.3M|   }
_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|  13.3M|      {
   73|  13.3M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.3M|         else {
   84|  13.3M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  13.3M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  13.3M|      }
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|  13.3M|      {
   59|  13.3M|         return Rule::match( in );
   60|  13.3M|      }
_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|  37.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.7k|      else {
  108|  37.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.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|  37.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|  37.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|  37.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|  37.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|  37.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|  37.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.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|  37.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.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|  37.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.39k, False: 35.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|  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|  37.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.39k, False: 35.3k]
  ------------------
  157|  2.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.39k|         }
  159|  35.3k|         else {
  160|  35.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  35.3k|         }
  162|  37.7k|         (void)m( result );
  163|  37.7k|         return result;
  164|  37.7k|      }
  165|  37.7k|   }
_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|  37.7k|      {
   73|  37.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|  37.7k|         else {
   84|  37.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.7k|      }
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|  37.7k|      {
   44|  37.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.7k|      }
_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|  37.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.7k|      else {
  108|  37.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.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|  37.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|  37.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|  37.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|  37.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|  37.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|  37.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.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|  37.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.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|  37.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.39k, False: 35.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|  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|  37.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.39k, False: 35.3k]
  ------------------
  157|  2.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.39k|         }
  159|  35.3k|         else {
  160|  35.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  35.3k|         }
  162|  37.7k|         (void)m( result );
  163|  37.7k|         return result;
  164|  37.7k|      }
  165|  37.7k|   }
_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|  37.7k|      {
   73|  37.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|  37.7k|         else {
   84|  37.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.7k|      }
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|  37.7k|      {
   44|  37.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.7k|      }
_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|  37.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.7k|      else {
  108|  37.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.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): [True: 0, Folded]
  ------------------
  112|  37.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|  37.7k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 37.7k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  37.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|  37.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|  37.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|  37.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.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|  37.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.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|  37.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 37.7k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.99k, False: 34.7k]
  ------------------
  143|  2.99k|            if constexpr( has_apply_void ) {
  144|  2.99k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.99k|         }
  156|  37.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.99k, False: 34.7k]
  ------------------
  157|  2.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.99k|         }
  159|  34.7k|         else {
  160|  34.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  34.7k|         }
  162|  37.7k|         (void)m( result );
  163|  37.7k|         return result;
  164|  37.7k|      }
  165|  37.7k|   }
_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|  37.7k|      {
   73|  37.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|  37.7k|         else {
   84|  37.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.7k|      }
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|  37.7k|      {
   59|  37.7k|         return Rule::match( in );
   60|  37.7k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  8.47k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.47k|      else {
  108|  8.47k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.47k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.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|  8.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|  8.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|  8.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|  8.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|  8.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|  8.47k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.47k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.47k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.47k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.47k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.47k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.47k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.47k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.47k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.47k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.87k, False: 1.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|  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.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.87k, False: 1.60k]
  ------------------
  157|  6.87k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.87k|         }
  159|  1.60k|         else {
  160|  1.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.60k|         }
  162|  8.47k|         (void)m( result );
  163|  8.47k|         return result;
  164|  8.47k|      }
  165|  8.47k|   }
_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|  8.47k|      {
   73|  8.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|  8.47k|         else {
   84|  8.47k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.47k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.47k|      }
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|  8.47k|      {
   44|  8.47k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.47k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  8.47k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.47k|      else {
  108|  8.47k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.47k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.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|  8.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|  8.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|  8.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|  8.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|  8.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|  8.47k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.47k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.47k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.47k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.47k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.47k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.47k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.47k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.47k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.47k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.87k, False: 1.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|  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.47k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.87k, False: 1.60k]
  ------------------
  157|  6.87k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.87k|         }
  159|  1.60k|         else {
  160|  1.60k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.60k|         }
  162|  8.47k|         (void)m( result );
  163|  8.47k|         return result;
  164|  8.47k|      }
  165|  8.47k|   }
_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|  8.47k|      {
   73|  8.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|  8.47k|         else {
   84|  8.47k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.47k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.47k|      }
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|  8.47k|      {
   59|  8.47k|         return Rule::match( in );
   60|  8.47k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  14.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  14.4k|      else {
  108|  14.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  14.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  14.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|  14.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|  14.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|  14.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|  14.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|  14.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|  14.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  14.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  14.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  14.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|  14.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  14.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  14.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|  14.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  14.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  14.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  14.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  14.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.70k, False: 10.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.70k|            else if constexpr( has_apply0_bool ) {
  153|  3.70k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.70k|            }
  155|  3.70k|         }
  156|  14.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.70k, False: 10.7k]
  ------------------
  157|  3.70k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.70k|         }
  159|  10.7k|         else {
  160|  10.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.7k|         }
  162|  14.4k|         (void)m( result );
  163|  14.4k|         return result;
  164|  14.4k|      }
  165|  14.4k|   }
_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|  14.4k|      {
   73|  14.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|  14.4k|         else {
   84|  14.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  14.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  14.4k|      }
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|  14.4k|      {
   59|  14.4k|         return Rule::match( in );
   60|  14.4k|      }
_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|  2.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.97k|      else {
  108|  2.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.97k|         constexpr bool has_apply_void = enable_action && internal::has_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.97k|         constexpr bool has_apply_bool = enable_action && internal::has_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.97k|         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.97k|         constexpr bool has_apply0_void = enable_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.97k|         constexpr bool has_apply0_bool = enable_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.97k|         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.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.97k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.97k|         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.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.39k, False: 587]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.39k, False: 587]
  ------------------
  157|  2.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.39k|         }
  159|    587|         else {
  160|    587|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    587|         }
  162|  2.97k|         (void)m( result );
  163|  2.97k|         return result;
  164|  2.97k|      }
  165|  2.97k|   }
_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|  2.97k|      {
   73|  2.97k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.97k|         else {
   84|  2.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.97k|      }
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|  2.97k|      {
   44|  2.97k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.97k|      }
_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|  2.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.97k|      else {
  108|  2.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.97k|         constexpr bool has_apply_void = enable_action && internal::has_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.97k|         constexpr bool has_apply_bool = enable_action && internal::has_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.97k|         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.97k|         constexpr bool has_apply0_void = enable_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.97k|         constexpr bool has_apply0_bool = enable_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.97k|         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.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.97k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.97k|         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.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.80k, 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|  1.80k|            else if constexpr( has_apply0_bool ) {
  153|  1.80k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.80k|            }
  155|  1.80k|         }
  156|  2.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.80k, False: 1.17k]
  ------------------
  157|  1.80k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.80k|         }
  159|  1.17k|         else {
  160|  1.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.17k|         }
  162|  2.97k|         (void)m( result );
  163|  2.97k|         return result;
  164|  2.97k|      }
  165|  2.97k|   }
_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|  2.97k|      {
   73|  2.97k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.97k|         else {
   84|  2.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.97k|      }
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|  2.97k|      {
   44|  2.97k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.97k|      }
_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|  2.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.97k|      else {
  108|  2.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.97k|         constexpr bool has_apply_void = enable_action && internal::has_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.97k|         constexpr bool has_apply_bool = enable_action && internal::has_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.97k|         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.97k|         constexpr bool has_apply0_void = enable_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.97k|         constexpr bool has_apply0_bool = enable_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.97k|         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.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.97k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.97k|         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.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.97k, 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.97k|            else if constexpr( has_apply0_bool ) {
  153|  2.97k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.97k|            }
  155|  2.97k|         }
  156|  2.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.97k, False: 0]
  ------------------
  157|  2.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.97k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  2.97k|         (void)m( result );
  163|  2.97k|         return result;
  164|  2.97k|      }
  165|  2.97k|   }
_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|  2.97k|      {
   73|  2.97k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.97k|         else {
   84|  2.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.97k|      }
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|  2.97k|      {
   44|  2.97k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.97k|      }
_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|  2.97k|   {
  104|  2.97k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.97k|         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.97k|   }
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|  2.97k|      {
   44|  2.97k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.97k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.97k|      else {
  108|  2.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.97k|         constexpr bool has_apply_void = 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.97k|         constexpr bool has_apply_bool = enable_action && internal::has_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.97k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 2.97k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  2.97k|         constexpr bool has_apply0_void = enable_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.97k|         constexpr bool has_apply0_bool = enable_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.97k|         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.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.97k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.97k|         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.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 2.97k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.26k, False: 1.71k]
  ------------------
  143|  1.26k|            if constexpr( has_apply_void ) {
  144|  1.26k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.26k|         }
  156|  2.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.26k, False: 1.71k]
  ------------------
  157|  1.26k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.26k|         }
  159|  1.71k|         else {
  160|  1.71k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.71k|         }
  162|  2.97k|         (void)m( result );
  163|  2.97k|         return result;
  164|  2.97k|      }
  165|  2.97k|   }
_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|  2.97k|      {
   73|  2.97k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.97k|         else {
   84|  2.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.97k|      }
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|  2.97k|      {
   44|  2.97k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.97k|      }
_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|  2.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.97k|      else {
  108|  2.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.97k|         constexpr bool has_apply_void = enable_action && internal::has_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.97k|         constexpr bool has_apply_bool = enable_action && internal::has_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.97k|         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.97k|         constexpr bool has_apply0_void = enable_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.97k|         constexpr bool has_apply0_bool = enable_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.97k|         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.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.97k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.97k|         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.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 209, False: 2.76k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  2.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 209, False: 2.76k]
  ------------------
  157|    209|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    209|         }
  159|  2.76k|         else {
  160|  2.76k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.76k|         }
  162|  2.97k|         (void)m( result );
  163|  2.97k|         return result;
  164|  2.97k|      }
  165|  2.97k|   }
_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|  2.97k|      {
   73|  2.97k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.97k|         else {
   84|  2.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.97k|      }
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|  2.97k|      {
   59|  2.97k|         return Rule::match( in );
   60|  2.97k|      }
_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|  2.76k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.76k|      else {
  108|  2.76k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.76k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.76k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.76k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.76k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.76k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.76k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.76k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.76k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.76k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.76k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.76k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 227, False: 2.54k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.76k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 227, False: 2.54k]
  ------------------
  157|    227|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    227|         }
  159|  2.54k|         else {
  160|  2.54k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.54k|         }
  162|  2.76k|         (void)m( result );
  163|  2.76k|         return result;
  164|  2.76k|      }
  165|  2.76k|   }
_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|  2.76k|      {
   73|  2.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|  2.76k|         else {
   84|  2.76k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.76k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.76k|      }
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|  2.76k|      {
   59|  2.76k|         return Rule::match( in );
   60|  2.76k|      }
_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|  2.54k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.54k|      else {
  108|  2.54k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.54k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.54k|         constexpr bool has_apply_void = enable_action && internal::has_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.54k|         constexpr bool has_apply_bool = enable_action && internal::has_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.54k|         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.54k|         constexpr bool has_apply0_void = enable_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.54k|         constexpr bool has_apply0_bool = enable_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.54k|         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.54k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.54k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.54k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.54k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.54k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.54k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.54k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.54k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.54k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.54k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.54k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.54k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 383, 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|    383|            else if constexpr( has_apply0_bool ) {
  153|    383|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    383|            }
  155|    383|         }
  156|  2.54k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 383, False: 2.15k]
  ------------------
  157|    383|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    383|         }
  159|  2.15k|         else {
  160|  2.15k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.15k|         }
  162|  2.54k|         (void)m( result );
  163|  2.54k|         return result;
  164|  2.54k|      }
  165|  2.54k|   }
_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|  2.54k|      {
   73|  2.54k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.54k|         else {
   84|  2.54k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.54k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.54k|      }
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|  2.54k|      {
   59|  2.54k|         return Rule::match( in );
   60|  2.54k|      }
_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.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: 120, False: 2.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|    120|            else if constexpr( has_apply0_bool ) {
  153|    120|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    120|            }
  155|    120|         }
  156|  2.15k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 120, False: 2.03k]
  ------------------
  157|    120|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    120|         }
  159|  2.03k|         else {
  160|  2.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.03k|         }
  162|  2.15k|         (void)m( result );
  163|  2.15k|         return result;
  164|  2.15k|      }
  165|  2.15k|   }
_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.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_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.15k|      {
   59|  2.15k|         return Rule::match( in );
   60|  2.15k|      }
_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.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.03k|      else {
  108|  2.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.03k|         constexpr bool has_apply_void = enable_action && internal::has_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.03k|         constexpr bool has_apply_bool = enable_action && internal::has_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.03k|         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.03k|         constexpr bool has_apply0_void = enable_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.03k|         constexpr bool has_apply0_bool = enable_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.03k|         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.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 260, 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|    260|            else if constexpr( has_apply0_bool ) {
  153|    260|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    260|            }
  155|    260|         }
  156|  2.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 260, False: 1.77k]
  ------------------
  157|    260|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    260|         }
  159|  1.77k|         else {
  160|  1.77k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.77k|         }
  162|  2.03k|         (void)m( result );
  163|  2.03k|         return result;
  164|  2.03k|      }
  165|  2.03k|   }
_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.03k|      {
   73|  2.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.03k|         else {
   84|  2.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.03k|      }
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.03k|      {
   59|  2.03k|         return Rule::match( in );
   60|  2.03k|      }
_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|  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: 68, False: 1.71k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|     68|            else if constexpr( has_apply0_bool ) {
  153|     68|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     68|            }
  155|     68|         }
  156|  1.77k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 68, False: 1.71k]
  ------------------
  157|     68|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     68|         }
  159|  1.71k|         else {
  160|  1.71k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.71k|         }
  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_19parent_hash_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_19parent_hash_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_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.97k|      else {
  108|  2.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.97k|         constexpr bool has_apply_void = enable_action && internal::has_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.97k|         constexpr bool has_apply_bool = enable_action && internal::has_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.97k|         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.97k|         constexpr bool has_apply0_void = enable_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.97k|         constexpr bool has_apply0_bool = enable_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.97k|         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.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.97k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.97k|         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.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.99k, False: 985]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.99k, False: 985]
  ------------------
  157|  1.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.99k|         }
  159|    985|         else {
  160|    985|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    985|         }
  162|  2.97k|         (void)m( result );
  163|  2.97k|         return result;
  164|  2.97k|      }
  165|  2.97k|   }
_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|  2.97k|      {
   73|  2.97k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.97k|         else {
   84|  2.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.97k|      }
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|  2.97k|      {
   59|  2.97k|         return Rule::match( in );
   60|  2.97k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.90k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.90k|      else {
  108|  3.90k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.90k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.90k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.90k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.90k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.90k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.90k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.90k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.90k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.90k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.90k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.90k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.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|  3.90k|            else if constexpr( has_apply0_bool ) {
  153|  3.90k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.90k|            }
  155|  3.90k|         }
  156|  3.90k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.90k, False: 0]
  ------------------
  157|  3.90k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.90k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.90k|         (void)m( result );
  163|  3.90k|         return result;
  164|  3.90k|      }
  165|  3.90k|   }
_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|  3.90k|      {
   73|  3.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|  3.90k|         else {
   84|  3.90k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.90k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.90k|      }
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|  3.90k|      {
   44|  3.90k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.90k|      }
_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|  1.99k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.99k|      else {
  108|  1.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.99k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.99k|         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.99k|         constexpr bool has_apply0_void = enable_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.99k|         constexpr bool has_apply0_bool = enable_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.99k|         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.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.91k, 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|  1.91k|            else if constexpr( has_apply0_bool ) {
  153|  1.91k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.91k|            }
  155|  1.91k|         }
  156|  1.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.91k, False: 75]
  ------------------
  157|  1.91k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.91k|         }
  159|     75|         else {
  160|     75|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     75|         }
  162|  1.99k|         (void)m( result );
  163|  1.99k|         return result;
  164|  1.99k|      }
  165|  1.99k|   }
_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|  1.99k|      {
   73|  1.99k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.99k|         else {
   84|  1.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.99k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  1.99k|      {
   44|  1.99k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.99k|      }
_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|  1.93k|   {
  104|  1.93k|      if constexpr( !Control< Rule >::enable ) {
  105|  1.93k|         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.93k|   }
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|  1.93k|      {
   44|  1.93k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.93k|      }
_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|  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_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|  4.22k|      {
   44|  4.22k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.22k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.91k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.91k|      else {
  108|  1.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.80k, False: 114]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.80k|            else if constexpr( has_apply0_bool ) {
  153|  1.80k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.80k|            }
  155|  1.80k|         }
  156|  1.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.80k, False: 114]
  ------------------
  157|  1.80k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.80k|         }
  159|    114|         else {
  160|    114|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    114|         }
  162|  1.91k|         (void)m( result );
  163|  1.91k|         return result;
  164|  1.91k|      }
  165|  1.91k|   }
_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|  1.91k|      {
   73|  1.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|  1.91k|         else {
   84|  1.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.91k|      }
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|  1.91k|      {
   59|  1.91k|         return Rule::match( in );
   60|  1.91k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.80k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.80k|      else {
  108|  5.80k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.80k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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): [True: 0, Folded]
  ------------------
  112|  5.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|  5.80k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 5.80k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.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|  5.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|  5.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|  5.80k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.80k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.80k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.80k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.80k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.80k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 5.80k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.80k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.80k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.80k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.80k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.84k, False: 961]
  ------------------
  143|  4.84k|            if constexpr( has_apply_void ) {
  144|  4.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|  4.84k|         }
  156|  5.80k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.80k, False: 997]
  ------------------
  157|  4.80k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.80k|         }
  159|    997|         else {
  160|    997|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    997|         }
  162|  5.80k|         (void)m( result );
  163|  5.80k|         return result;
  164|  5.80k|      }
  165|  5.80k|   }
_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|  5.80k|      {
   73|  5.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|  5.80k|         else {
   84|  5.80k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.80k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.80k|      }
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|  5.80k|      {
   44|  5.80k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.80k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.80k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.80k|      else {
  108|  5.80k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.80k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.80k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.80k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.80k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.80k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.80k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.80k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.80k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.80k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.80k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.80k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.10k, False: 704]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.80k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.10k, False: 704]
  ------------------
  157|  5.10k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.10k|         }
  159|    704|         else {
  160|    704|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    704|         }
  162|  5.80k|         (void)m( result );
  163|  5.80k|         return result;
  164|  5.80k|      }
  165|  5.80k|   }
_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|  5.80k|      {
   73|  5.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|  5.80k|         else {
   84|  5.80k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.80k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.80k|      }
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|  5.80k|      {
   59|  5.80k|         return Rule::match( in );
   60|  5.80k|      }
_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|  5.10k|   {
  104|  5.10k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.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|  5.10k|   }
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|  5.10k|      {
   44|  5.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.10k|      }
_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|  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: 4.84k, False: 257]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.84k|            else if constexpr( has_apply0_bool ) {
  153|  4.84k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.84k|            }
  155|  4.84k|         }
  156|  5.10k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.84k, False: 257]
  ------------------
  157|  4.84k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.84k|         }
  159|    257|         else {
  160|    257|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    257|         }
  162|  5.10k|         (void)m( result );
  163|  5.10k|         return result;
  164|  5.10k|      }
  165|  5.10k|   }
_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|  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_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|  5.10k|      {
   44|  5.10k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.10k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.89M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.89M|      else {
  108|  5.89M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.89M|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.89M|         constexpr bool has_apply_void = enable_action && internal::has_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.89M|         constexpr bool has_apply_bool = enable_action && internal::has_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.89M|         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.89M|         constexpr bool has_apply0_void = enable_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.89M|         constexpr bool has_apply0_bool = enable_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.89M|         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.89M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.89M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.89M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.89M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.89M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.89M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.89M|         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.89M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.89M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.89M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.89M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.89M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.84k, False: 5.88M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.84k|            else if constexpr( has_apply0_bool ) {
  153|  4.84k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.84k|            }
  155|  4.84k|         }
  156|  5.89M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.84k, False: 5.88M]
  ------------------
  157|  4.84k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.84k|         }
  159|  5.88M|         else {
  160|  5.88M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.88M|         }
  162|  5.89M|         (void)m( result );
  163|  5.89M|         return result;
  164|  5.89M|      }
  165|  5.89M|   }
_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|  5.89M|      {
   73|  5.89M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.89M|         else {
   84|  5.89M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.89M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.89M|      }
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|  5.89M|      {
   59|  5.89M|         return Rule::match( in );
   60|  5.89M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.88M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.88M|      else {
  108|  5.88M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.88M|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.88M|         constexpr bool has_apply_void = enable_action && internal::has_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.88M|         constexpr bool has_apply_bool = enable_action && internal::has_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.88M|         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.88M|         constexpr bool has_apply0_void = enable_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.88M|         constexpr bool has_apply0_bool = enable_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.88M|         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.88M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.88M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.88M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.88M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.88M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.88M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.88M|         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.88M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.88M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.88M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.88M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.88M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.88M, False: 257]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.88M|            else if constexpr( has_apply0_bool ) {
  153|  5.88M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.88M|            }
  155|  5.88M|         }
  156|  5.88M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.88M, False: 257]
  ------------------
  157|  5.88M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.88M|         }
  159|    257|         else {
  160|    257|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    257|         }
  162|  5.88M|         (void)m( result );
  163|  5.88M|         return result;
  164|  5.88M|      }
  165|  5.88M|   }
_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|  5.88M|      {
   73|  5.88M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.88M|         else {
   84|  5.88M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.88M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.88M|      }
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|  5.88M|      {
   44|  5.88M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.88M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.88M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.88M|      else {
  108|  5.88M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.88M|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.88M|         constexpr bool has_apply_void = enable_action && internal::has_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.88M|         constexpr bool has_apply_bool = enable_action && internal::has_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.88M|         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.88M|         constexpr bool has_apply0_void = enable_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.88M|         constexpr bool has_apply0_bool = enable_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.88M|         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.88M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.88M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.88M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.88M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.88M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.88M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.88M|         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.88M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.88M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.88M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.88M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.88M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 100k, False: 5.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|   100k|            else if constexpr( has_apply0_bool ) {
  153|   100k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   100k|            }
  155|   100k|         }
  156|  5.88M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 100k, False: 5.78M]
  ------------------
  157|   100k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   100k|         }
  159|  5.78M|         else {
  160|  5.78M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.78M|         }
  162|  5.88M|         (void)m( result );
  163|  5.88M|         return result;
  164|  5.88M|      }
  165|  5.88M|   }
_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|  5.88M|      {
   73|  5.88M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.88M|         else {
   84|  5.88M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.88M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.88M|      }
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|  5.88M|      {
   44|  5.88M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.88M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.88M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.88M|      else {
  108|  5.88M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.88M|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.88M|         constexpr bool has_apply_void = enable_action && internal::has_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.88M|         constexpr bool has_apply_bool = enable_action && internal::has_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.88M|         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.88M|         constexpr bool has_apply0_void = enable_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.88M|         constexpr bool has_apply0_bool = enable_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.88M|         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.88M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.88M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.88M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.88M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.88M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.88M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.88M|         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.88M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.88M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.88M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.88M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.88M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 100k, False: 5.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|   100k|            else if constexpr( has_apply0_bool ) {
  153|   100k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   100k|            }
  155|   100k|         }
  156|  5.88M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 100k, False: 5.78M]
  ------------------
  157|   100k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   100k|         }
  159|  5.78M|         else {
  160|  5.78M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.78M|         }
  162|  5.88M|         (void)m( result );
  163|  5.88M|         return result;
  164|  5.88M|      }
  165|  5.88M|   }
_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|  5.88M|      {
   73|  5.88M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.88M|         else {
   84|  5.88M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.88M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.88M|      }
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|  5.88M|      {
   59|  5.88M|         return Rule::match( in );
   60|  5.88M|      }
_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|   100k|   {
  104|   100k|      if constexpr( !Control< Rule >::enable ) {
  105|   100k|         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|   100k|   }
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|   100k|      {
   44|   100k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   100k|      }
_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|   100k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   100k|      else {
  108|   100k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   100k|         using iterator_t = typename ParseInput::iterator_t;
  111|   100k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   100k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   100k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   100k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   100k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   100k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   100k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   100k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   100k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   100k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   100k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   100k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   100k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   100k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   100k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   100k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   100k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   100k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 100k, False: 96]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   100k|            else if constexpr( has_apply0_bool ) {
  153|   100k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   100k|            }
  155|   100k|         }
  156|   100k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 100k, False: 96]
  ------------------
  157|   100k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   100k|         }
  159|     96|         else {
  160|     96|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     96|         }
  162|   100k|         (void)m( result );
  163|   100k|         return result;
  164|   100k|      }
  165|   100k|   }
_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|   100k|      {
   73|   100k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   100k|         else {
   84|   100k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   100k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   100k|      }
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|   100k|      {
   44|   100k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   100k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   100k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   100k|      else {
  108|   100k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   100k|         using iterator_t = typename ParseInput::iterator_t;
  111|   100k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   100k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   100k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   100k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   100k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   100k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   100k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   100k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   100k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   100k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   100k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   100k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   100k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   100k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   100k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   100k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   100k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   100k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 36.0k, False: 64.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|  36.0k|            else if constexpr( has_apply0_bool ) {
  153|  36.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  36.0k|            }
  155|  36.0k|         }
  156|   100k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 36.0k, False: 64.4k]
  ------------------
  157|  36.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  36.0k|         }
  159|  64.4k|         else {
  160|  64.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  64.4k|         }
  162|   100k|         (void)m( result );
  163|   100k|         return result;
  164|   100k|      }
  165|   100k|   }
_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|   100k|      {
   73|   100k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   100k|         else {
   84|   100k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   100k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   100k|      }
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|   100k|      {
   44|   100k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   100k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   100k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   100k|      else {
  108|   100k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   100k|         using iterator_t = typename ParseInput::iterator_t;
  111|   100k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   100k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   100k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   100k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   100k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   100k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   100k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   100k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   100k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   100k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   100k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   100k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   100k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   100k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   100k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   100k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   100k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   100k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 36.0k, False: 64.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|  36.0k|            else if constexpr( has_apply0_bool ) {
  153|  36.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  36.0k|            }
  155|  36.0k|         }
  156|   100k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 36.0k, False: 64.4k]
  ------------------
  157|  36.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  36.0k|         }
  159|  64.4k|         else {
  160|  64.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  64.4k|         }
  162|   100k|         (void)m( result );
  163|   100k|         return result;
  164|   100k|      }
  165|   100k|   }
_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|   100k|      {
   73|   100k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   100k|         else {
   84|   100k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   100k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   100k|      }
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|   100k|      {
   59|   100k|         return Rule::match( in );
   60|   100k|      }
_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|  36.0k|   {
  104|  36.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  36.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|  36.0k|   }
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|  36.0k|      {
   44|  36.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  36.0k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  36.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  36.0k|      else {
  108|  36.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  36.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  36.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|  36.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|  36.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|  36.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|  36.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|  36.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|  36.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  36.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  36.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  36.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|  36.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  36.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  36.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|  36.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  36.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  36.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  36.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  36.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 36.0k, False: 36]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  36.0k|            else if constexpr( has_apply0_bool ) {
  153|  36.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  36.0k|            }
  155|  36.0k|         }
  156|  36.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 36.0k, False: 36]
  ------------------
  157|  36.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  36.0k|         }
  159|     36|         else {
  160|     36|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     36|         }
  162|  36.0k|         (void)m( result );
  163|  36.0k|         return result;
  164|  36.0k|      }
  165|  36.0k|   }
_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|  36.0k|      {
   73|  36.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|  36.0k|         else {
   84|  36.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  36.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  36.0k|      }
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|  36.0k|      {
   44|  36.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  36.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  72.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  72.0k|      else {
  108|  72.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  72.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  72.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|  72.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|  72.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|  72.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|  72.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|  72.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|  72.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  72.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  72.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  72.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|  72.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  72.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  72.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|  72.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  72.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  72.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  72.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  72.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 72.0k, False: 36]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  72.0k|            else if constexpr( has_apply0_bool ) {
  153|  72.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  72.0k|            }
  155|  72.0k|         }
  156|  72.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 72.0k, False: 36]
  ------------------
  157|  72.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  72.0k|         }
  159|     36|         else {
  160|     36|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     36|         }
  162|  72.0k|         (void)m( result );
  163|  72.0k|         return result;
  164|  72.0k|      }
  165|  72.0k|   }
_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|  72.0k|      {
   73|  72.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|  72.0k|         else {
   84|  72.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  72.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  72.0k|      }
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|  72.0k|      {
   59|  72.0k|         return Rule::match( in );
   60|  72.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  64.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  64.4k|      else {
  108|  64.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  64.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  64.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|  64.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|  64.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|  64.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|  64.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|  64.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|  64.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  64.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  64.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  64.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|  64.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  64.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  64.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|  64.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  64.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  64.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  64.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  64.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 22.0k, False: 42.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|  22.0k|            else if constexpr( has_apply0_bool ) {
  153|  22.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  22.0k|            }
  155|  22.0k|         }
  156|  64.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 22.0k, False: 42.3k]
  ------------------
  157|  22.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  22.0k|         }
  159|  42.3k|         else {
  160|  42.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  42.3k|         }
  162|  64.4k|         (void)m( result );
  163|  64.4k|         return result;
  164|  64.4k|      }
  165|  64.4k|   }
_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|  64.4k|      {
   73|  64.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|  64.4k|         else {
   84|  64.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  64.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  64.4k|      }
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|  64.4k|      {
   44|  64.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  64.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  95.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  95.6k|      else {
  108|  95.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  95.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  95.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|  95.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|  95.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|  95.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|  95.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|  95.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|  95.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  95.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  95.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  95.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|  95.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  95.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  95.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|  95.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  95.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  95.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  95.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  95.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.5k, False: 57.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|  38.5k|            else if constexpr( has_apply0_bool ) {
  153|  38.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.5k|            }
  155|  38.5k|         }
  156|  95.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.5k, False: 57.1k]
  ------------------
  157|  38.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.5k|         }
  159|  57.1k|         else {
  160|  57.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  57.1k|         }
  162|  95.6k|         (void)m( result );
  163|  95.6k|         return result;
  164|  95.6k|      }
  165|  95.6k|   }
_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|  95.6k|      {
   73|  95.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|  95.6k|         else {
   84|  95.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  95.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  95.6k|      }
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|  95.6k|      {
   59|  95.6k|         return Rule::match( in );
   60|  95.6k|      }
_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|  22.0k|   {
  104|  22.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  22.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|  22.0k|   }
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|  22.0k|      {
   44|  22.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  22.0k|      }
_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|  22.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.0k|      else {
  108|  22.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.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|  22.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|  22.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|  22.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|  22.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|  22.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|  22.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.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|  22.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.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|  22.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 22.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|  22.0k|            else if constexpr( has_apply0_bool ) {
  153|  22.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  22.0k|            }
  155|  22.0k|         }
  156|  22.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 22.0k, False: 0]
  ------------------
  157|  22.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  22.0k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  22.0k|         (void)m( result );
  163|  22.0k|         return result;
  164|  22.0k|      }
  165|  22.0k|   }
_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|  22.0k|      {
   73|  22.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|  22.0k|         else {
   84|  22.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.0k|      }
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|  22.0k|      {
   44|  22.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  22.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  42.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.3k|      else {
  108|  42.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.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|  42.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|  42.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|  42.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|  42.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|  42.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|  42.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.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|  42.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.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|  42.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 41.6k, False: 718]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  41.6k|            else if constexpr( has_apply0_bool ) {
  153|  41.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  41.6k|            }
  155|  41.6k|         }
  156|  42.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 41.6k, False: 718]
  ------------------
  157|  41.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  41.6k|         }
  159|    718|         else {
  160|    718|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    718|         }
  162|  42.3k|         (void)m( result );
  163|  42.3k|         return result;
  164|  42.3k|      }
  165|  42.3k|   }
_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|  42.3k|      {
   73|  42.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|  42.3k|         else {
   84|  42.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.3k|      }
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|  42.3k|      {
   59|  42.3k|         return Rule::match( in );
   60|  42.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    718|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    718|      else {
  108|    718|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    718|         using iterator_t = typename ParseInput::iterator_t;
  111|    718|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    718|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    718|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    718|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    718|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    718|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    718|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    718|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    718|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    718|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    718|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    718|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    718|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    718|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    718|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    718|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    718|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    718|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 658, 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|    658|            else if constexpr( has_apply0_bool ) {
  153|    658|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    658|            }
  155|    658|         }
  156|    718|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 658, False: 60]
  ------------------
  157|    658|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    658|         }
  159|     60|         else {
  160|     60|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     60|         }
  162|    718|         (void)m( result );
  163|    718|         return result;
  164|    718|      }
  165|    718|   }
_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|    718|      {
   73|    718|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    718|         else {
   84|    718|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    718|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    718|      }
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|    718|      {
   59|    718|         return Rule::match( in );
   60|    718|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.78M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.78M|      else {
  108|  5.78M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.78M|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.78M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.78M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.78M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.78M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.78M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.78M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.78M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.78M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.78M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.78M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.78M, 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|  5.78M|            else if constexpr( has_apply0_bool ) {
  153|  5.78M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.78M|            }
  155|  5.78M|         }
  156|  5.78M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.78M, False: 161]
  ------------------
  157|  5.78M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.78M|         }
  159|    161|         else {
  160|    161|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    161|         }
  162|  5.78M|         (void)m( result );
  163|  5.78M|         return result;
  164|  5.78M|      }
  165|  5.78M|   }
_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|  5.78M|      {
   73|  5.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|  5.78M|         else {
   84|  5.78M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.78M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.78M|      }
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|  5.78M|      {
   59|  5.78M|         return Rule::match( in );
   60|  5.78M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser16serial_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  35.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  35.0k|      else {
  108|  35.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  35.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  35.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|  35.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|  35.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|  35.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|  35.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|  35.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|  35.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  35.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  35.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  35.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|  35.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  35.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  35.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|  35.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  35.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  35.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  35.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  35.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.96k, False: 32.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.96k|            else if constexpr( has_apply0_bool ) {
  153|  2.96k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.96k|            }
  155|  2.96k|         }
  156|  35.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.96k, False: 32.0k]
  ------------------
  157|  2.96k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.96k|         }
  159|  32.0k|         else {
  160|  32.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  32.0k|         }
  162|  35.0k|         (void)m( result );
  163|  35.0k|         return result;
  164|  35.0k|      }
  165|  35.0k|   }
_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|  35.0k|      {
   73|  35.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|  35.0k|         else {
   84|  35.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  35.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  35.0k|      }
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|  35.0k|      {
   44|  35.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  35.0k|      }
_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|  35.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  35.0k|      else {
  108|  35.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  35.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  35.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|  35.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|  35.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|  35.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|  35.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|  35.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|  35.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  35.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  35.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  35.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|  35.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  35.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  35.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|  35.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  35.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  35.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  35.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  35.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.96k, False: 32.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.96k|            else if constexpr( has_apply0_bool ) {
  153|  2.96k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.96k|            }
  155|  2.96k|         }
  156|  35.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.96k, False: 32.0k]
  ------------------
  157|  2.96k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.96k|         }
  159|  32.0k|         else {
  160|  32.0k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  32.0k|         }
  162|  35.0k|         (void)m( result );
  163|  35.0k|         return result;
  164|  35.0k|      }
  165|  35.0k|   }
_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|  35.0k|      {
   73|  35.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|  35.0k|         else {
   84|  35.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  35.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  35.0k|      }
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|  35.0k|      {
   44|  35.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  35.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_serialELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  35.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  35.0k|      else {
  108|  35.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  35.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  35.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): [True: 0, Folded]
  ------------------
  112|  35.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|  35.0k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 35.0k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  35.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|  35.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|  35.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|  35.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  35.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  35.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  35.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|  35.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  35.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  35.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|  35.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 35.0k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  35.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  35.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  35.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  35.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.44k, False: 31.5k]
  ------------------
  143|  3.44k|            if constexpr( has_apply_void ) {
  144|  3.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|  3.44k|         }
  156|  35.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.44k, False: 31.5k]
  ------------------
  157|  3.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.44k|         }
  159|  31.5k|         else {
  160|  31.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  31.5k|         }
  162|  35.0k|         (void)m( result );
  163|  35.0k|         return result;
  164|  35.0k|      }
  165|  35.0k|   }
_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|  35.0k|      {
   73|  35.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|  35.0k|         else {
   84|  35.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  35.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  35.0k|      }
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|  35.0k|      {
   59|  35.0k|         return Rule::match( in );
   60|  35.0k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  8.99k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.99k|      else {
  108|  8.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.99k|         constexpr bool has_apply_bool = enable_action && internal::has_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.99k|         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.99k|         constexpr bool has_apply0_void = enable_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.99k|         constexpr bool has_apply0_bool = enable_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.99k|         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.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.39k, False: 1.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|  7.39k|            else if constexpr( has_apply0_bool ) {
  153|  7.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.39k|            }
  155|  7.39k|         }
  156|  8.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.39k, False: 1.59k]
  ------------------
  157|  7.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.39k|         }
  159|  1.59k|         else {
  160|  1.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.59k|         }
  162|  8.99k|         (void)m( result );
  163|  8.99k|         return result;
  164|  8.99k|      }
  165|  8.99k|   }
_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.99k|      {
   73|  8.99k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.99k|         else {
   84|  8.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.99k|      }
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.99k|      {
   44|  8.99k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.99k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  8.99k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.99k|      else {
  108|  8.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  8.99k|         constexpr bool has_apply_bool = enable_action && internal::has_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.99k|         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.99k|         constexpr bool has_apply0_void = enable_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.99k|         constexpr bool has_apply0_bool = enable_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.99k|         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.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.39k, False: 1.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|  7.39k|            else if constexpr( has_apply0_bool ) {
  153|  7.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.39k|            }
  155|  7.39k|         }
  156|  8.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.39k, False: 1.59k]
  ------------------
  157|  7.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.39k|         }
  159|  1.59k|         else {
  160|  1.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.59k|         }
  162|  8.99k|         (void)m( result );
  163|  8.99k|         return result;
  164|  8.99k|      }
  165|  8.99k|   }
_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.99k|      {
   73|  8.99k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.99k|         else {
   84|  8.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.99k|      }
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.99k|      {
   59|  8.99k|         return Rule::match( in );
   60|  8.99k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  15.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  15.6k|      else {
  108|  15.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.6k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  15.6k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  15.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|  15.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|  15.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|  15.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|  15.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.6k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.6k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  15.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  15.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.50k, False: 11.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.50k|            else if constexpr( has_apply0_bool ) {
  153|  4.50k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.50k|            }
  155|  4.50k|         }
  156|  15.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.50k, False: 11.1k]
  ------------------
  157|  4.50k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.50k|         }
  159|  11.1k|         else {
  160|  11.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  11.1k|         }
  162|  15.6k|         (void)m( result );
  163|  15.6k|         return result;
  164|  15.6k|      }
  165|  15.6k|   }
_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.6k|      {
   73|  15.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|  15.6k|         else {
   84|  15.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.6k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  15.6k|      {
   59|  15.6k|         return Rule::match( in );
   60|  15.6k|      }
_ZN3tao5pegtl5matchINS0_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|  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: 2.96k, False: 457]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.96k|            else if constexpr( has_apply0_bool ) {
  153|  2.96k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.96k|            }
  155|  2.96k|         }
  156|  3.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.96k, False: 457]
  ------------------
  157|  2.96k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.96k|         }
  159|    457|         else {
  160|    457|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    457|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_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|  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_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|  3.42k|      {
   44|  3.42k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.42k|      }
_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|  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: 1.76k, False: 1.65k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  3.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.76k, False: 1.65k]
  ------------------
  157|  1.76k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.76k|         }
  159|  1.65k|         else {
  160|  1.65k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.65k|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_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|  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_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|  3.42k|      {
   44|  3.42k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.42k|      }
_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|  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: 3.42k, 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.42k|            else if constexpr( has_apply0_bool ) {
  153|  3.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.42k|            }
  155|  3.42k|         }
  156|  3.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.42k, False: 0]
  ------------------
  157|  3.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.42k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_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|  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_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|  3.42k|      {
   44|  3.42k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.42k|      }
_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|  3.42k|   {
  104|  3.42k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.42k|         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.42k|   }
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|  3.42k|      {
   44|  3.42k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.42k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_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): [True: 0, Folded]
  ------------------
  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): [True: 3.42k, Folded]
  |  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): [True: 3.42k, Folded]
  |  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: 1.38k, False: 2.04k]
  ------------------
  143|  1.38k|            if constexpr( has_apply_void ) {
  144|  1.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|  1.38k|         }
  156|  3.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.38k, False: 2.04k]
  ------------------
  157|  1.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.38k|         }
  159|  2.04k|         else {
  160|  2.04k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.04k|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_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|  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_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|  3.42k|      {
   44|  3.42k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.42k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_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: 248, False: 3.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|    248|            else if constexpr( has_apply0_bool ) {
  153|    248|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    248|            }
  155|    248|         }
  156|  3.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 248, False: 3.17k]
  ------------------
  157|    248|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    248|         }
  159|  3.17k|         else {
  160|  3.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.17k|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_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|  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_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|  3.42k|      {
   59|  3.42k|         return Rule::match( in );
   60|  3.42k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.17k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.17k|      else {
  108|  3.17k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.17k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.17k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.17k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.17k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.17k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.17k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.17k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.17k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.17k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.17k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.17k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.17k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.17k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.17k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.17k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 200, False: 2.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|    200|            else if constexpr( has_apply0_bool ) {
  153|    200|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    200|            }
  155|    200|         }
  156|  3.17k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 200, False: 2.97k]
  ------------------
  157|    200|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    200|         }
  159|  2.97k|         else {
  160|  2.97k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.97k|         }
  162|  3.17k|         (void)m( result );
  163|  3.17k|         return result;
  164|  3.17k|      }
  165|  3.17k|   }
_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|  3.17k|      {
   73|  3.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|  3.17k|         else {
   84|  3.17k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.17k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.17k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser10str_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|  3.17k|      {
   59|  3.17k|         return Rule::match( in );
   60|  3.17k|      }
_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.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.97k|      else {
  108|  2.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.97k|         constexpr bool has_apply_void = enable_action && internal::has_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.97k|         constexpr bool has_apply_bool = enable_action && internal::has_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.97k|         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.97k|         constexpr bool has_apply0_void = enable_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.97k|         constexpr bool has_apply0_bool = enable_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.97k|         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.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.97k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.97k|         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.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, False: 2.78k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  2.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.78k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.78k|         else {
  160|  2.78k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.78k|         }
  162|  2.97k|         (void)m( result );
  163|  2.97k|         return result;
  164|  2.97k|      }
  165|  2.97k|   }
_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.97k|      {
   73|  2.97k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.97k|         else {
   84|  2.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.97k|      }
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.97k|      {
   59|  2.97k|         return Rule::match( in );
   60|  2.97k|      }
_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.78k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.78k|      else {
  108|  2.78k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.78k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.78k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.78k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.78k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.78k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.78k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.78k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.78k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.78k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.78k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.78k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 186, 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|    186|            else if constexpr( has_apply0_bool ) {
  153|    186|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    186|            }
  155|    186|         }
  156|  2.78k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 186, False: 2.59k]
  ------------------
  157|    186|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    186|         }
  159|  2.59k|         else {
  160|  2.59k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.59k|         }
  162|  2.78k|         (void)m( result );
  163|  2.78k|         return result;
  164|  2.78k|      }
  165|  2.78k|   }
_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.78k|      {
   73|  2.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|  2.78k|         else {
   84|  2.78k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.78k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.78k|      }
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.78k|      {
   59|  2.78k|         return Rule::match( in );
   60|  2.78k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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: 334, False: 2.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|    334|            else if constexpr( has_apply0_bool ) {
  153|    334|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    334|            }
  155|    334|         }
  156|  2.59k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 334, False: 2.26k]
  ------------------
  157|    334|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    334|         }
  159|  2.26k|         else {
  160|  2.26k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.26k|         }
  162|  2.59k|         (void)m( result );
  163|  2.59k|         return result;
  164|  2.59k|      }
  165|  2.59k|   }
_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.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_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.59k|      {
   59|  2.59k|         return Rule::match( in );
   60|  2.59k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.26k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.26k|      else {
  108|  2.26k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.26k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.26k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  2.26k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  2.26k|         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.26k|         constexpr bool has_apply0_void = enable_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.26k|         constexpr bool has_apply0_bool = enable_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.26k|         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.26k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.26k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.26k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.26k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.26k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.26k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.26k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.26k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.26k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.26k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.26k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.26k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 222, False: 2.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|    222|            else if constexpr( has_apply0_bool ) {
  153|    222|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    222|            }
  155|    222|         }
  156|  2.26k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 222, False: 2.04k]
  ------------------
  157|    222|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    222|         }
  159|  2.04k|         else {
  160|  2.04k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.04k|         }
  162|  2.26k|         (void)m( result );
  163|  2.26k|         return result;
  164|  2.26k|      }
  165|  2.26k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  2.26k|      {
   73|  2.26k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.26k|         else {
   84|  2.26k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.26k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.26k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  2.26k|      {
   59|  2.26k|         return Rule::match( in );
   60|  2.26k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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: 1.91k, 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|  1.91k|            else if constexpr( has_apply0_bool ) {
  153|  1.91k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.91k|            }
  155|  1.91k|         }
  156|  3.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.91k, False: 1.50k]
  ------------------
  157|  1.91k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.91k|         }
  159|  1.50k|         else {
  160|  1.50k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.50k|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_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_controlINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.42k|      {
   59|  3.42k|         return Rule::match( in );
   60|  3.42k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.78k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.78k|      else {
  108|  3.78k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.78k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.78k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.78k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.78k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.78k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.78k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.78k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.78k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.78k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.78k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.78k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.78k, 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.78k|            else if constexpr( has_apply0_bool ) {
  153|  3.78k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.78k|            }
  155|  3.78k|         }
  156|  3.78k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.78k, False: 0]
  ------------------
  157|  3.78k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.78k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.78k|         (void)m( result );
  163|  3.78k|         return result;
  164|  3.78k|      }
  165|  3.78k|   }
_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.78k|      {
   73|  3.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|  3.78k|         else {
   84|  3.78k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.78k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.78k|      }
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.78k|      {
   44|  3.78k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.78k|      }
_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.91k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.91k|      else {
  108|  1.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.86k, 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|  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|  1.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.86k, False: 54]
  ------------------
  157|  1.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.86k|         }
  159|     54|         else {
  160|     54|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     54|         }
  162|  1.91k|         (void)m( result );
  163|  1.91k|         return result;
  164|  1.91k|      }
  165|  1.91k|   }
_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.91k|      {
   73|  1.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|  1.91k|         else {
   84|  1.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.91k|      }
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.91k|      {
   44|  1.91k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.91k|      }
_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.87k|   {
  104|  1.87k|      if constexpr( !Control< Rule >::enable ) {
  105|  1.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|  1.87k|   }
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.87k|      {
   44|  1.87k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.87k|      }
_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|  4.17k|   {
  104|  4.17k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.17k|         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.17k|   }
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|  4.17k|      {
   44|  4.17k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.17k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.86k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.86k|      else {
  108|  1.86k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.86k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.86k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.86k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.86k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.86k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.86k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.86k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.86k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.86k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.86k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.86k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.76k, False: 96]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.86k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.76k, False: 96]
  ------------------
  157|  1.76k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.76k|         }
  159|     96|         else {
  160|     96|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     96|         }
  162|  1.86k|         (void)m( result );
  163|  1.86k|         return result;
  164|  1.86k|      }
  165|  1.86k|   }
_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.86k|      {
   73|  1.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|  1.86k|         else {
   84|  1.86k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.86k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.86k|      }
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.86k|      {
   59|  1.86k|         return Rule::match( in );
   60|  1.86k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.16k|      else {
  108|  6.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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): [True: 0, Folded]
  ------------------
  112|  6.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|  6.16k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 6.16k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.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|  6.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|  6.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|  6.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 6.16k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.39k, False: 774]
  ------------------
  143|  5.39k|            if constexpr( has_apply_void ) {
  144|  5.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|  5.39k|         }
  156|  6.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.37k, False: 793]
  ------------------
  157|  5.37k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.37k|         }
  159|    793|         else {
  160|    793|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    793|         }
  162|  6.16k|         (void)m( result );
  163|  6.16k|         return result;
  164|  6.16k|      }
  165|  6.16k|   }
_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|  6.16k|      {
   73|  6.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|  6.16k|         else {
   84|  6.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.16k|      }
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|  6.16k|      {
   44|  6.16k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.16k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.16k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.16k|      else {
  108|  6.16k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.16k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.16k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.16k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.16k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.16k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.16k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.16k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.16k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.16k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.16k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.16k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.59k, False: 568]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.59k|            else if constexpr( has_apply0_bool ) {
  153|  5.59k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.59k|            }
  155|  5.59k|         }
  156|  6.16k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.59k, False: 568]
  ------------------
  157|  5.59k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.59k|         }
  159|    568|         else {
  160|    568|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    568|         }
  162|  6.16k|         (void)m( result );
  163|  6.16k|         return result;
  164|  6.16k|      }
  165|  6.16k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.16k|      {
   73|  6.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|  6.16k|         else {
   84|  6.16k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.16k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.16k|      }
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|  6.16k|      {
   59|  6.16k|         return Rule::match( in );
   60|  6.16k|      }
_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|  5.59k|   {
  104|  5.59k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.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|  5.59k|   }
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|  5.59k|      {
   44|  5.59k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.59k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  5.59k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.59k|      else {
  108|  5.59k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.59k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.59k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  5.59k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  5.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|  5.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|  5.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|  5.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|  5.59k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.59k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.59k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.59k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.59k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.59k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.59k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  5.59k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.59k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.59k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.59k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.59k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.39k, False: 206]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.59k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.39k, False: 206]
  ------------------
  157|  5.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.39k|         }
  159|    206|         else {
  160|    206|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    206|         }
  162|  5.59k|         (void)m( result );
  163|  5.59k|         return result;
  164|  5.59k|      }
  165|  5.59k|   }
_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|  5.59k|      {
   73|  5.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|  5.59k|         else {
   84|  5.59k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.59k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.59k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  5.59k|      {
   44|  5.59k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.59k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.88M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.88M|      else {
  108|  2.88M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.88M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.88M|         constexpr bool has_apply_void = enable_action && internal::has_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.88M|         constexpr bool has_apply_bool = enable_action && internal::has_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.88M|         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.88M|         constexpr bool has_apply0_void = enable_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.88M|         constexpr bool has_apply0_bool = enable_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.88M|         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.88M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.88M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.88M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.88M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.88M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.88M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.88M|         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.88M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.88M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.88M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.88M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.88M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.39k, False: 2.87M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  2.88M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.39k, False: 2.87M]
  ------------------
  157|  5.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.39k|         }
  159|  2.87M|         else {
  160|  2.87M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.87M|         }
  162|  2.88M|         (void)m( result );
  163|  2.88M|         return result;
  164|  2.88M|      }
  165|  2.88M|   }
_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.88M|      {
   73|  2.88M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.88M|         else {
   84|  2.88M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.88M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.88M|      }
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.88M|      {
   59|  2.88M|         return Rule::match( in );
   60|  2.88M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.87M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.87M|      else {
  108|  2.87M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.87M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.87M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.87M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.87M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.87M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.87M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.87M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.87M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.87M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.87M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.87M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.87M, False: 206]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.87M|            else if constexpr( has_apply0_bool ) {
  153|  2.87M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.87M|            }
  155|  2.87M|         }
  156|  2.87M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.87M, False: 206]
  ------------------
  157|  2.87M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.87M|         }
  159|    206|         else {
  160|    206|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    206|         }
  162|  2.87M|         (void)m( result );
  163|  2.87M|         return result;
  164|  2.87M|      }
  165|  2.87M|   }
_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.87M|      {
   73|  2.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|  2.87M|         else {
   84|  2.87M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.87M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.87M|      }
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.87M|      {
   44|  2.87M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.87M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.87M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.87M|      else {
  108|  2.87M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.87M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.87M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.87M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.87M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.87M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.87M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.87M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.87M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.87M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.87M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.87M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 21.9k, False: 2.85M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.9k|            else if constexpr( has_apply0_bool ) {
  153|  21.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  21.9k|            }
  155|  21.9k|         }
  156|  2.87M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 21.9k, False: 2.85M]
  ------------------
  157|  21.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  21.9k|         }
  159|  2.85M|         else {
  160|  2.85M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.85M|         }
  162|  2.87M|         (void)m( result );
  163|  2.87M|         return result;
  164|  2.87M|      }
  165|  2.87M|   }
_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.87M|      {
   73|  2.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|  2.87M|         else {
   84|  2.87M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.87M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.87M|      }
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.87M|      {
   44|  2.87M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.87M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.87M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.87M|      else {
  108|  2.87M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.87M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.87M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.87M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.87M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.87M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.87M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.87M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.87M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.87M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.87M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.87M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 22.0k, False: 2.85M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  22.0k|            else if constexpr( has_apply0_bool ) {
  153|  22.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  22.0k|            }
  155|  22.0k|         }
  156|  2.87M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 22.0k, False: 2.85M]
  ------------------
  157|  22.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  22.0k|         }
  159|  2.85M|         else {
  160|  2.85M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.85M|         }
  162|  2.87M|         (void)m( result );
  163|  2.87M|         return result;
  164|  2.87M|      }
  165|  2.87M|   }
_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.87M|      {
   73|  2.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|  2.87M|         else {
   84|  2.87M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.87M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.87M|      }
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.87M|      {
   59|  2.87M|         return Rule::match( in );
   60|  2.87M|      }
_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|  22.0k|   {
  104|  22.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  22.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|  22.0k|   }
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|  22.0k|      {
   44|  22.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  22.0k|      }
_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|  22.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.0k|      else {
  108|  22.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.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|  22.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|  22.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|  22.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|  22.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|  22.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|  22.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.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|  22.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.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|  22.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 21.9k, 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|  21.9k|            else if constexpr( has_apply0_bool ) {
  153|  21.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  21.9k|            }
  155|  21.9k|         }
  156|  22.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 21.9k, False: 41]
  ------------------
  157|  21.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  21.9k|         }
  159|     41|         else {
  160|     41|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     41|         }
  162|  22.0k|         (void)m( result );
  163|  22.0k|         return result;
  164|  22.0k|      }
  165|  22.0k|   }
_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|  22.0k|      {
   73|  22.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|  22.0k|         else {
   84|  22.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.0k|      }
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|  22.0k|      {
   44|  22.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  22.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  22.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.0k|      else {
  108|  22.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.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|  22.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|  22.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|  22.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|  22.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|  22.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|  22.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.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|  22.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.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|  22.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.80k, False: 16.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.80k|            else if constexpr( has_apply0_bool ) {
  153|  5.80k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.80k|            }
  155|  5.80k|         }
  156|  22.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.80k, False: 16.2k]
  ------------------
  157|  5.80k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.80k|         }
  159|  16.2k|         else {
  160|  16.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.2k|         }
  162|  22.0k|         (void)m( result );
  163|  22.0k|         return result;
  164|  22.0k|      }
  165|  22.0k|   }
_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|  22.0k|      {
   73|  22.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|  22.0k|         else {
   84|  22.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.0k|      }
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|  22.0k|      {
   44|  22.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  22.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  22.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  22.0k|      else {
  108|  22.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  22.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  22.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|  22.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|  22.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|  22.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|  22.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|  22.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|  22.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  22.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  22.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  22.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|  22.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  22.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  22.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|  22.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  22.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  22.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  22.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  22.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.82k, False: 16.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.82k|            else if constexpr( has_apply0_bool ) {
  153|  5.82k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.82k|            }
  155|  5.82k|         }
  156|  22.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.82k, False: 16.2k]
  ------------------
  157|  5.82k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.82k|         }
  159|  16.2k|         else {
  160|  16.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.2k|         }
  162|  22.0k|         (void)m( result );
  163|  22.0k|         return result;
  164|  22.0k|      }
  165|  22.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  22.0k|      {
   73|  22.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|  22.0k|         else {
   84|  22.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  22.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  22.0k|      }
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|  22.0k|      {
   59|  22.0k|         return Rule::match( in );
   60|  22.0k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  5.82k|   {
  104|  5.82k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.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|  5.82k|   }
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|  5.82k|      {
   44|  5.82k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.82k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_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: 5.80k, False: 21]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.80k|            else if constexpr( has_apply0_bool ) {
  153|  5.80k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.80k|            }
  155|  5.80k|         }
  156|  5.82k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.80k, False: 21]
  ------------------
  157|  5.80k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.80k|         }
  159|     21|         else {
  160|     21|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     21|         }
  162|  5.82k|         (void)m( result );
  163|  5.82k|         return result;
  164|  5.82k|      }
  165|  5.82k|   }
_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|  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_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|  5.82k|      {
   44|  5.82k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.82k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  11.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  11.6k|      else {
  108|  11.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  11.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  11.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|  11.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|  11.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|  11.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|  11.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|  11.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|  11.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  11.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  11.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  11.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|  11.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  11.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  11.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|  11.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  11.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  11.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  11.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  11.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 11.6k, False: 21]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  11.6k|            else if constexpr( has_apply0_bool ) {
  153|  11.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  11.6k|            }
  155|  11.6k|         }
  156|  11.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 11.6k, False: 21]
  ------------------
  157|  11.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  11.6k|         }
  159|     21|         else {
  160|     21|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     21|         }
  162|  11.6k|         (void)m( result );
  163|  11.6k|         return result;
  164|  11.6k|      }
  165|  11.6k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  11.6k|      {
   73|  11.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|  11.6k|         else {
   84|  11.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  11.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  11.6k|      }
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|  11.6k|      {
   59|  11.6k|         return Rule::match( in );
   60|  11.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  16.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  16.2k|      else {
  108|  16.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  16.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  16.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|  16.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|  16.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|  16.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|  16.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|  16.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|  16.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  16.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  16.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  16.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|  16.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  16.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  16.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|  16.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  16.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  16.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  16.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  16.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.13k, False: 8.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|  8.13k|            else if constexpr( has_apply0_bool ) {
  153|  8.13k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.13k|            }
  155|  8.13k|         }
  156|  16.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.13k, False: 8.07k]
  ------------------
  157|  8.13k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.13k|         }
  159|  8.07k|         else {
  160|  8.07k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  8.07k|         }
  162|  16.2k|         (void)m( result );
  163|  16.2k|         return result;
  164|  16.2k|      }
  165|  16.2k|   }
_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|  16.2k|      {
   73|  16.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|  16.2k|         else {
   84|  16.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  16.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  16.2k|      }
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|  16.2k|      {
   44|  16.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  16.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  25.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  25.3k|      else {
  108|  25.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  25.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  25.3k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  25.3k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  25.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|  25.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|  25.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|  25.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|  25.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  25.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  25.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  25.3k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  25.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  25.3k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  25.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  25.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  25.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  25.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  25.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.92k, False: 15.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|  9.92k|            else if constexpr( has_apply0_bool ) {
  153|  9.92k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.92k|            }
  155|  9.92k|         }
  156|  25.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.92k, False: 15.4k]
  ------------------
  157|  9.92k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.92k|         }
  159|  15.4k|         else {
  160|  15.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  15.4k|         }
  162|  25.3k|         (void)m( result );
  163|  25.3k|         return result;
  164|  25.3k|      }
  165|  25.3k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  25.3k|      {
   73|  25.3k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.3k|         else {
   84|  25.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  25.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  25.3k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  25.3k|      {
   59|  25.3k|         return Rule::match( in );
   60|  25.3k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  8.13k|   {
  104|  8.13k|      if constexpr( !Control< Rule >::enable ) {
  105|  8.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|  8.13k|   }
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|  8.13k|      {
   44|  8.13k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.13k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  8.13k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.13k|      else {
  108|  8.13k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.13k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.13k|         constexpr bool has_apply_void = enable_action && internal::has_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.13k|         constexpr bool has_apply_bool = enable_action && internal::has_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.13k|         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.13k|         constexpr bool has_apply0_void = enable_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.13k|         constexpr bool has_apply0_bool = enable_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.13k|         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.13k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.13k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.13k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.13k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.13k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.13k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.13k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.13k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.13k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.13k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.13k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.13k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.13k, 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|  8.13k|            else if constexpr( has_apply0_bool ) {
  153|  8.13k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.13k|            }
  155|  8.13k|         }
  156|  8.13k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.13k, False: 0]
  ------------------
  157|  8.13k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.13k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  8.13k|         (void)m( result );
  163|  8.13k|         return result;
  164|  8.13k|      }
  165|  8.13k|   }
_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|  8.13k|      {
   73|  8.13k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.13k|         else {
   84|  8.13k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.13k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.13k|      }
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|  8.13k|      {
   44|  8.13k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.13k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  8.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.07k|      else {
  108|  8.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.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|  8.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|  8.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|  8.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|  8.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|  8.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|  8.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.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|  8.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.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|  8.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.72k, False: 352]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.72k|            else if constexpr( has_apply0_bool ) {
  153|  7.72k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.72k|            }
  155|  7.72k|         }
  156|  8.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.72k, False: 352]
  ------------------
  157|  7.72k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.72k|         }
  159|    352|         else {
  160|    352|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    352|         }
  162|  8.07k|         (void)m( result );
  163|  8.07k|         return result;
  164|  8.07k|      }
  165|  8.07k|   }
_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|  8.07k|      {
   73|  8.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|  8.07k|         else {
   84|  8.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.07k|      }
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|  8.07k|      {
   59|  8.07k|         return Rule::match( in );
   60|  8.07k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    352|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    352|      else {
  108|    352|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    352|         using iterator_t = typename ParseInput::iterator_t;
  111|    352|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    352|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    352|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    352|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    352|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    352|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    352|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    352|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    352|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    352|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    352|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    352|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    352|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    352|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    352|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    352|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    352|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    352|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 332, False: 20]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|    352|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 332, False: 20]
  ------------------
  157|    332|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    332|         }
  159|     20|         else {
  160|     20|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     20|         }
  162|    352|         (void)m( result );
  163|    352|         return result;
  164|    352|      }
  165|    352|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    352|      {
   73|    352|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    352|         else {
   84|    352|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    352|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    352|      }
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|    352|      {
   59|    352|         return Rule::match( in );
   60|    352|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  2.85M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.85M|      else {
  108|  2.85M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.85M|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.85M|         constexpr bool has_apply_void = enable_action && internal::has_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.85M|         constexpr bool has_apply_bool = enable_action && internal::has_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.85M|         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.85M|         constexpr bool has_apply0_void = enable_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.85M|         constexpr bool has_apply0_bool = enable_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.85M|         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.85M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.85M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.85M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.85M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.85M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.85M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.85M|         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.85M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.85M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.85M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.85M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.85M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.85M, False: 165]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.85M|            else if constexpr( has_apply0_bool ) {
  153|  2.85M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.85M|            }
  155|  2.85M|         }
  156|  2.85M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.85M, False: 165]
  ------------------
  157|  2.85M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.85M|         }
  159|    165|         else {
  160|    165|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    165|         }
  162|  2.85M|         (void)m( result );
  163|  2.85M|         return result;
  164|  2.85M|      }
  165|  2.85M|   }
_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.85M|      {
   73|  2.85M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.85M|         else {
   84|  2.85M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.85M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.85M|      }
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.85M|      {
   59|  2.85M|         return Rule::match( in );
   60|  2.85M|      }
_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|  31.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  31.8k|      else {
  108|  31.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.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|  31.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|  31.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|  31.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|  31.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|  31.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|  31.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.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|  31.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.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|  31.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  31.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.39k, False: 29.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.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|  31.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.39k, False: 29.4k]
  ------------------
  157|  2.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.39k|         }
  159|  29.4k|         else {
  160|  29.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  29.4k|         }
  162|  31.8k|         (void)m( result );
  163|  31.8k|         return result;
  164|  31.8k|      }
  165|  31.8k|   }
_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|  31.8k|      {
   73|  31.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|  31.8k|         else {
   84|  31.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  31.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  31.8k|      }
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|  31.8k|      {
   44|  31.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  31.8k|      }
_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|  31.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  31.8k|      else {
  108|  31.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.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|  31.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|  31.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|  31.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|  31.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|  31.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|  31.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.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|  31.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.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|  31.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  31.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.39k, False: 29.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.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|  31.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.39k, False: 29.4k]
  ------------------
  157|  2.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.39k|         }
  159|  29.4k|         else {
  160|  29.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  29.4k|         }
  162|  31.8k|         (void)m( result );
  163|  31.8k|         return result;
  164|  31.8k|      }
  165|  31.8k|   }
_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|  31.8k|      {
   73|  31.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|  31.8k|         else {
   84|  31.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  31.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  31.8k|      }
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|  31.8k|      {
   44|  31.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  31.8k|      }
_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|  31.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  31.8k|      else {
  108|  31.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.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|  31.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|  31.8k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 31.8k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  31.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|  31.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|  31.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|  31.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.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|  31.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.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|  31.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 31.8k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  31.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.04k, False: 28.7k]
  ------------------
  143|  3.04k|            if constexpr( has_apply_void ) {
  144|  3.04k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.04k|         }
  156|  31.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.04k, False: 28.7k]
  ------------------
  157|  3.04k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.04k|         }
  159|  28.7k|         else {
  160|  28.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  28.7k|         }
  162|  31.8k|         (void)m( result );
  163|  31.8k|         return result;
  164|  31.8k|      }
  165|  31.8k|   }
_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|  31.8k|      {
   73|  31.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|  31.8k|         else {
   84|  31.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  31.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  31.8k|      }
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|  31.8k|      {
   59|  31.8k|         return Rule::match( in );
   60|  31.8k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  8.24k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.24k|      else {
  108|  8.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.24k|         constexpr bool has_apply_void = enable_action && internal::has_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.24k|         constexpr bool has_apply_bool = enable_action && internal::has_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.24k|         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.24k|         constexpr bool has_apply0_void = enable_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.24k|         constexpr bool has_apply0_bool = enable_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.24k|         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.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.24k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.24k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.86k, False: 1.37k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.86k|            else if constexpr( has_apply0_bool ) {
  153|  6.86k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.86k|            }
  155|  6.86k|         }
  156|  8.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.86k, False: 1.37k]
  ------------------
  157|  6.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.86k|         }
  159|  1.37k|         else {
  160|  1.37k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.37k|         }
  162|  8.24k|         (void)m( result );
  163|  8.24k|         return result;
  164|  8.24k|      }
  165|  8.24k|   }
_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|  8.24k|      {
   73|  8.24k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.24k|         else {
   84|  8.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.24k|      }
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|  8.24k|      {
   44|  8.24k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.24k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  8.24k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.24k|      else {
  108|  8.24k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.24k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.24k|         constexpr bool has_apply_void = enable_action && internal::has_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.24k|         constexpr bool has_apply_bool = enable_action && internal::has_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.24k|         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.24k|         constexpr bool has_apply0_void = enable_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.24k|         constexpr bool has_apply0_bool = enable_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.24k|         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.24k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.24k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.24k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.24k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.24k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.24k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.24k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.24k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.24k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.24k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.24k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.24k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.86k, False: 1.37k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.86k|            else if constexpr( has_apply0_bool ) {
  153|  6.86k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.86k|            }
  155|  6.86k|         }
  156|  8.24k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.86k, False: 1.37k]
  ------------------
  157|  6.86k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.86k|         }
  159|  1.37k|         else {
  160|  1.37k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.37k|         }
  162|  8.24k|         (void)m( result );
  163|  8.24k|         return result;
  164|  8.24k|      }
  165|  8.24k|   }
_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|  8.24k|      {
   73|  8.24k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.24k|         else {
   84|  8.24k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.24k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.24k|      }
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|  8.24k|      {
   59|  8.24k|         return Rule::match( in );
   60|  8.24k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  15.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  15.2k|      else {
  108|  15.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.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|  15.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|  15.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|  15.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|  15.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|  15.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|  15.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.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|  15.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.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|  15.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  15.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.47k, False: 10.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|  4.47k|            else if constexpr( has_apply0_bool ) {
  153|  4.47k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.47k|            }
  155|  4.47k|         }
  156|  15.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.47k, False: 10.7k]
  ------------------
  157|  4.47k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.47k|         }
  159|  10.7k|         else {
  160|  10.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.7k|         }
  162|  15.2k|         (void)m( result );
  163|  15.2k|         return result;
  164|  15.2k|      }
  165|  15.2k|   }
_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|  15.2k|      {
   73|  15.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|  15.2k|         else {
   84|  15.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.2k|      }
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|  15.2k|      {
   59|  15.2k|         return Rule::match( in );
   60|  15.2k|      }
_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.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.03k|      else {
  108|  3.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.03k|         constexpr bool has_apply_void = enable_action && internal::has_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.03k|         constexpr bool has_apply_bool = enable_action && internal::has_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.03k|         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.03k|         constexpr bool has_apply0_void = enable_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.03k|         constexpr bool has_apply0_bool = enable_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.03k|         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.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.39k, False: 634]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  3.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.39k, False: 634]
  ------------------
  157|  2.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.39k|         }
  159|    634|         else {
  160|    634|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    634|         }
  162|  3.03k|         (void)m( result );
  163|  3.03k|         return result;
  164|  3.03k|      }
  165|  3.03k|   }
_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.03k|      {
   73|  3.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.03k|         else {
   84|  3.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.03k|      }
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.03k|      {
   44|  3.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.03k|      }
_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.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.03k|      else {
  108|  3.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.03k|         constexpr bool has_apply_void = enable_action && internal::has_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.03k|         constexpr bool has_apply_bool = enable_action && internal::has_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.03k|         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.03k|         constexpr bool has_apply0_void = enable_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.03k|         constexpr bool has_apply0_bool = enable_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.03k|         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.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.79k, 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|  1.79k|            else if constexpr( has_apply0_bool ) {
  153|  1.79k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.79k|            }
  155|  1.79k|         }
  156|  3.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.79k, False: 1.23k]
  ------------------
  157|  1.79k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.79k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|  3.03k|         (void)m( result );
  163|  3.03k|         return result;
  164|  3.03k|      }
  165|  3.03k|   }
_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.03k|      {
   73|  3.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.03k|         else {
   84|  3.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.03k|      }
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.03k|      {
   44|  3.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.03k|      }
_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.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.03k|      else {
  108|  3.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.03k|         constexpr bool has_apply_void = enable_action && internal::has_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.03k|         constexpr bool has_apply_bool = enable_action && internal::has_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.03k|         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.03k|         constexpr bool has_apply0_void = enable_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.03k|         constexpr bool has_apply0_bool = enable_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.03k|         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.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.03k, 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.03k|            else if constexpr( has_apply0_bool ) {
  153|  3.03k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.03k|            }
  155|  3.03k|         }
  156|  3.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.03k, False: 0]
  ------------------
  157|  3.03k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.03k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.03k|         (void)m( result );
  163|  3.03k|         return result;
  164|  3.03k|      }
  165|  3.03k|   }
_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.03k|      {
   73|  3.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.03k|         else {
   84|  3.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.03k|      }
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.03k|      {
   44|  3.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.03k|      }
_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.03k|   {
  104|  3.03k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.03k|         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.03k|   }
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.03k|      {
   44|  3.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.03k|      }
_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.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.03k|      else {
  108|  3.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.03k|         constexpr bool has_apply_void = 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.03k|         constexpr bool has_apply_bool = enable_action && internal::has_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.03k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 3.03k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  3.03k|         constexpr bool has_apply0_void = enable_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.03k|         constexpr bool has_apply0_bool = enable_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.03k|         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.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 3.03k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.22k, False: 1.80k]
  ------------------
  143|  1.22k|            if constexpr( has_apply_void ) {
  144|  1.22k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.22k|         }
  156|  3.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.22k, False: 1.80k]
  ------------------
  157|  1.22k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.22k|         }
  159|  1.80k|         else {
  160|  1.80k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.80k|         }
  162|  3.03k|         (void)m( result );
  163|  3.03k|         return result;
  164|  3.03k|      }
  165|  3.03k|   }
_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.03k|      {
   73|  3.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.03k|         else {
   84|  3.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.03k|      }
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.03k|      {
   44|  3.03k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.03k|      }
_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.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.03k|      else {
  108|  3.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.03k|         constexpr bool has_apply_void = enable_action && internal::has_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.03k|         constexpr bool has_apply_bool = enable_action && internal::has_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.03k|         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.03k|         constexpr bool has_apply0_void = enable_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.03k|         constexpr bool has_apply0_bool = enable_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.03k|         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.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 90, 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|     90|            else if constexpr( has_apply0_bool ) {
  153|     90|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     90|            }
  155|     90|         }
  156|  3.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 90, False: 2.94k]
  ------------------
  157|     90|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     90|         }
  159|  2.94k|         else {
  160|  2.94k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.94k|         }
  162|  3.03k|         (void)m( result );
  163|  3.03k|         return result;
  164|  3.03k|      }
  165|  3.03k|   }
_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.03k|      {
   73|  3.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.03k|         else {
   84|  3.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.03k|      }
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.03k|      {
   59|  3.03k|         return Rule::match( in );
   60|  3.03k|      }
_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|  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: 95, 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|     95|            else if constexpr( has_apply0_bool ) {
  153|     95|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     95|            }
  155|     95|         }
  156|  2.94k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 95, False: 2.84k]
  ------------------
  157|     95|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     95|         }
  159|  2.84k|         else {
  160|  2.84k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.84k|         }
  162|  2.94k|         (void)m( result );
  163|  2.94k|         return result;
  164|  2.94k|      }
  165|  2.94k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_16via_port_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_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|  2.94k|      {
   59|  2.94k|         return Rule::match( in );
   60|  2.94k|      }
_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|  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: 194, False: 2.65k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  2.84k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 2.65k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  2.65k|         else {
  160|  2.65k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.65k|         }
  162|  2.84k|         (void)m( result );
  163|  2.84k|         return result;
  164|  2.84k|      }
  165|  2.84k|   }
_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|  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_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|  2.84k|      {
   59|  2.84k|         return Rule::match( in );
   60|  2.84k|      }
_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.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: 264, False: 2.38k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    264|            else if constexpr( has_apply0_bool ) {
  153|    264|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    264|            }
  155|    264|         }
  156|  2.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 264, False: 2.38k]
  ------------------
  157|    264|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    264|         }
  159|  2.38k|         else {
  160|  2.38k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.38k|         }
  162|  2.65k|         (void)m( result );
  163|  2.65k|         return result;
  164|  2.65k|      }
  165|  2.65k|   }
_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.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_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.65k|      {
   59|  2.65k|         return Rule::match( in );
   60|  2.65k|      }
_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.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: 387, False: 2.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|    387|            else if constexpr( has_apply0_bool ) {
  153|    387|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    387|            }
  155|    387|         }
  156|  2.38k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 387, False: 2.00k]
  ------------------
  157|    387|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    387|         }
  159|  2.00k|         else {
  160|  2.00k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.00k|         }
  162|  2.38k|         (void)m( result );
  163|  2.38k|         return result;
  164|  2.38k|      }
  165|  2.38k|   }
_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.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_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.38k|      {
   59|  2.38k|         return Rule::match( in );
   60|  2.38k|      }
_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.00k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.00k|      else {
  108|  2.00k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.00k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.00k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.00k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.00k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.00k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.00k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.00k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.00k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.00k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.00k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.00k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 195, False: 1.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|    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.00k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 195, False: 1.80k]
  ------------------
  157|    195|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    195|         }
  159|  1.80k|         else {
  160|  1.80k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.80k|         }
  162|  2.00k|         (void)m( result );
  163|  2.00k|         return result;
  164|  2.00k|      }
  165|  2.00k|   }
_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.00k|      {
   73|  2.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|  2.00k|         else {
   84|  2.00k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.00k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.00k|      }
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.00k|      {
   59|  2.00k|         return Rule::match( in );
   60|  2.00k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.03k|      else {
  108|  3.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.03k|         constexpr bool has_apply_void = enable_action && internal::has_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.03k|         constexpr bool has_apply_bool = enable_action && internal::has_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.03k|         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.03k|         constexpr bool has_apply0_void = enable_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.03k|         constexpr bool has_apply0_bool = enable_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.03k|         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.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.99k, False: 1.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.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.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.99k, False: 1.03k]
  ------------------
  157|  1.99k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.99k|         }
  159|  1.03k|         else {
  160|  1.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.03k|         }
  162|  3.03k|         (void)m( result );
  163|  3.03k|         return result;
  164|  3.03k|      }
  165|  3.03k|   }
_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.03k|      {
   73|  3.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.03k|         else {
   84|  3.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.03k|      }
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.03k|      {
   59|  3.03k|         return Rule::match( in );
   60|  3.03k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  3.91k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.91k|      else {
  108|  3.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.91k, 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.91k|            else if constexpr( has_apply0_bool ) {
  153|  3.91k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.91k|            }
  155|  3.91k|         }
  156|  3.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.91k, False: 0]
  ------------------
  157|  3.91k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.91k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  3.91k|         (void)m( result );
  163|  3.91k|         return result;
  164|  3.91k|      }
  165|  3.91k|   }
_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|  3.91k|      {
   73|  3.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|  3.91k|         else {
   84|  3.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.91k|      }
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|  3.91k|      {
   44|  3.91k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.91k|      }
_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|  1.99k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.99k|      else {
  108|  1.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.99k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  1.99k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  1.99k|         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.99k|         constexpr bool has_apply0_void = enable_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.99k|         constexpr bool has_apply0_bool = enable_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.99k|         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.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.91k, False: 79]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.91k|            else if constexpr( has_apply0_bool ) {
  153|  1.91k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.91k|            }
  155|  1.91k|         }
  156|  1.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.91k, False: 79]
  ------------------
  157|  1.91k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.91k|         }
  159|     79|         else {
  160|     79|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     79|         }
  162|  1.99k|         (void)m( result );
  163|  1.99k|         return result;
  164|  1.99k|      }
  165|  1.99k|   }
_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|  1.99k|      {
   73|  1.99k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.99k|         else {
   84|  1.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.99k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  1.99k|      {
   44|  1.99k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.99k|      }
_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|  1.93k|   {
  104|  1.93k|      if constexpr( !Control< Rule >::enable ) {
  105|  1.93k|         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.93k|   }
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|  1.93k|      {
   44|  1.93k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  1.93k|      }
_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|  3.97k|   {
  104|  3.97k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.97k|         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.97k|   }
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|  3.97k|      {
   44|  3.97k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.97k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.91k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.91k|      else {
  108|  1.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.79k, 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|  1.79k|            else if constexpr( has_apply0_bool ) {
  153|  1.79k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.79k|            }
  155|  1.79k|         }
  156|  1.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.79k, False: 126]
  ------------------
  157|  1.79k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.79k|         }
  159|    126|         else {
  160|    126|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    126|         }
  162|  1.91k|         (void)m( result );
  163|  1.91k|         return result;
  164|  1.91k|      }
  165|  1.91k|   }
_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|  1.91k|      {
   73|  1.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|  1.91k|         else {
   84|  1.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.91k|      }
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|  1.91k|      {
   59|  1.91k|         return Rule::match( in );
   60|  1.91k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.85k|      else {
  108|  5.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.85k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 5.85k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  5.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|  5.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|  5.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|  5.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 5.85k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.62k, False: 1.23k]
  ------------------
  143|  4.62k|            if constexpr( has_apply_void ) {
  144|  4.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|  4.62k|         }
  156|  5.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.57k, False: 1.28k]
  ------------------
  157|  4.57k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.57k|         }
  159|  1.28k|         else {
  160|  1.28k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.28k|         }
  162|  5.85k|         (void)m( result );
  163|  5.85k|         return result;
  164|  5.85k|      }
  165|  5.85k|   }
_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|  5.85k|      {
   73|  5.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|  5.85k|         else {
   84|  5.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.85k|      }
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|  5.85k|      {
   44|  5.85k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.85k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  5.85k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.85k|      else {
  108|  5.85k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.85k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.85k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.85k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.85k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.85k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.85k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.85k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.85k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.85k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.85k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.85k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.87k, False: 980]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.87k|            else if constexpr( has_apply0_bool ) {
  153|  4.87k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.87k|            }
  155|  4.87k|         }
  156|  5.85k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.87k, False: 980]
  ------------------
  157|  4.87k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.87k|         }
  159|    980|         else {
  160|    980|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    980|         }
  162|  5.85k|         (void)m( result );
  163|  5.85k|         return result;
  164|  5.85k|      }
  165|  5.85k|   }
_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|  5.85k|      {
   73|  5.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|  5.85k|         else {
   84|  5.85k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.85k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.85k|      }
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|  5.85k|      {
   59|  5.85k|         return Rule::match( in );
   60|  5.85k|      }
_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|  4.87k|   {
  104|  4.87k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.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|  4.87k|   }
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|  4.87k|      {
   44|  4.87k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.87k|      }
_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|  4.87k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.87k|      else {
  108|  4.87k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.87k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.87k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.87k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.87k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.87k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.87k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.87k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.87k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.87k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.87k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.87k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.62k, 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|  4.62k|            else if constexpr( has_apply0_bool ) {
  153|  4.62k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.62k|            }
  155|  4.62k|         }
  156|  4.87k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.62k, False: 255]
  ------------------
  157|  4.62k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.62k|         }
  159|    255|         else {
  160|    255|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    255|         }
  162|  4.87k|         (void)m( result );
  163|  4.87k|         return result;
  164|  4.87k|      }
  165|  4.87k|   }
_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|  4.87k|      {
   73|  4.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|  4.87k|         else {
   84|  4.87k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.87k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.87k|      }
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|  4.87k|      {
   44|  4.87k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.87k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.77M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.77M|      else {
  108|  6.77M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.77M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.77M|         constexpr bool has_apply_void = enable_action && internal::has_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.77M|         constexpr bool has_apply_bool = enable_action && internal::has_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.77M|         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.77M|         constexpr bool has_apply0_void = enable_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.77M|         constexpr bool has_apply0_bool = enable_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.77M|         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.77M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.77M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.77M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.77M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.77M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.77M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.77M|         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.77M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.77M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.77M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.77M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.77M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.62k, False: 6.76M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.62k|            else if constexpr( has_apply0_bool ) {
  153|  4.62k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.62k|            }
  155|  4.62k|         }
  156|  6.77M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.62k, False: 6.76M]
  ------------------
  157|  4.62k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.62k|         }
  159|  6.76M|         else {
  160|  6.76M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.76M|         }
  162|  6.77M|         (void)m( result );
  163|  6.77M|         return result;
  164|  6.77M|      }
  165|  6.77M|   }
_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.77M|      {
   73|  6.77M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.77M|         else {
   84|  6.77M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.77M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.77M|      }
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.77M|      {
   59|  6.77M|         return Rule::match( in );
   60|  6.77M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.76M|      else {
  108|  6.76M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76M|         constexpr bool has_apply_void = enable_action && internal::has_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.76M|         constexpr bool has_apply_bool = enable_action && internal::has_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.76M|         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.76M|         constexpr bool has_apply0_void = enable_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.76M|         constexpr bool has_apply0_bool = enable_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.76M|         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.76M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.76M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76M|         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.76M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.76M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.76M, 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|  6.76M|            else if constexpr( has_apply0_bool ) {
  153|  6.76M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.76M|            }
  155|  6.76M|         }
  156|  6.76M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.76M, False: 255]
  ------------------
  157|  6.76M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.76M|         }
  159|    255|         else {
  160|    255|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    255|         }
  162|  6.76M|         (void)m( result );
  163|  6.76M|         return result;
  164|  6.76M|      }
  165|  6.76M|   }
_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.76M|      {
   73|  6.76M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.76M|         else {
   84|  6.76M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76M|      }
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.76M|      {
   44|  6.76M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.76M|      }
_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.76M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.76M|      else {
  108|  6.76M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76M|         constexpr bool has_apply_void = enable_action && internal::has_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.76M|         constexpr bool has_apply_bool = enable_action && internal::has_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.76M|         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.76M|         constexpr bool has_apply0_void = enable_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.76M|         constexpr bool has_apply0_bool = enable_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.76M|         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.76M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.76M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76M|         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.76M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.76M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 45.3k, False: 6.72M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  45.3k|            else if constexpr( has_apply0_bool ) {
  153|  45.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  45.3k|            }
  155|  45.3k|         }
  156|  6.76M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 45.3k, False: 6.72M]
  ------------------
  157|  45.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  45.3k|         }
  159|  6.72M|         else {
  160|  6.72M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.72M|         }
  162|  6.76M|         (void)m( result );
  163|  6.76M|         return result;
  164|  6.76M|      }
  165|  6.76M|   }
_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.76M|      {
   73|  6.76M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.76M|         else {
   84|  6.76M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76M|      }
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.76M|      {
   44|  6.76M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.76M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.76M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.76M|      else {
  108|  6.76M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.76M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.76M|         constexpr bool has_apply_void = enable_action && internal::has_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.76M|         constexpr bool has_apply_bool = enable_action && internal::has_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.76M|         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.76M|         constexpr bool has_apply0_void = enable_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.76M|         constexpr bool has_apply0_bool = enable_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.76M|         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.76M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.76M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.76M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.76M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.76M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.76M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.76M|         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.76M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.76M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.76M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.76M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.76M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 45.4k, False: 6.72M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  45.4k|            else if constexpr( has_apply0_bool ) {
  153|  45.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  45.4k|            }
  155|  45.4k|         }
  156|  6.76M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 45.4k, False: 6.72M]
  ------------------
  157|  45.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  45.4k|         }
  159|  6.72M|         else {
  160|  6.72M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.72M|         }
  162|  6.76M|         (void)m( result );
  163|  6.76M|         return result;
  164|  6.76M|      }
  165|  6.76M|   }
_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.76M|      {
   73|  6.76M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.76M|         else {
   84|  6.76M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.76M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.76M|      }
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.76M|      {
   59|  6.76M|         return Rule::match( in );
   60|  6.76M|      }
_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|  45.4k|   {
  104|  45.4k|      if constexpr( !Control< Rule >::enable ) {
  105|  45.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|  45.4k|   }
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|  45.4k|      {
   44|  45.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  45.4k|      }
_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|  45.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.4k|      else {
  108|  45.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.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|  45.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|  45.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|  45.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|  45.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|  45.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|  45.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.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|  45.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.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|  45.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 45.3k, False: 72]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  45.3k|            else if constexpr( has_apply0_bool ) {
  153|  45.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  45.3k|            }
  155|  45.3k|         }
  156|  45.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 45.3k, False: 72]
  ------------------
  157|  45.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  45.3k|         }
  159|     72|         else {
  160|     72|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     72|         }
  162|  45.4k|         (void)m( result );
  163|  45.4k|         return result;
  164|  45.4k|      }
  165|  45.4k|   }
_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|  45.4k|      {
   73|  45.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|  45.4k|         else {
   84|  45.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.4k|      }
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|  45.4k|      {
   44|  45.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  45.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  45.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.4k|      else {
  108|  45.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.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|  45.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|  45.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|  45.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|  45.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|  45.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|  45.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.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|  45.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.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|  45.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 19.6k, 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|  19.6k|            else if constexpr( has_apply0_bool ) {
  153|  19.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  19.6k|            }
  155|  19.6k|         }
  156|  45.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 19.6k, False: 25.7k]
  ------------------
  157|  19.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  19.6k|         }
  159|  25.7k|         else {
  160|  25.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  25.7k|         }
  162|  45.4k|         (void)m( result );
  163|  45.4k|         return result;
  164|  45.4k|      }
  165|  45.4k|   }
_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|  45.4k|      {
   73|  45.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|  45.4k|         else {
   84|  45.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.4k|      }
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|  45.4k|      {
   44|  45.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  45.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  45.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  45.4k|      else {
  108|  45.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  45.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  45.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|  45.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|  45.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|  45.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|  45.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|  45.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|  45.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  45.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  45.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  45.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|  45.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  45.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  45.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|  45.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  45.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  45.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  45.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  45.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 19.7k, 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|  19.7k|            else if constexpr( has_apply0_bool ) {
  153|  19.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  19.7k|            }
  155|  19.7k|         }
  156|  45.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 19.7k, False: 25.7k]
  ------------------
  157|  19.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  19.7k|         }
  159|  25.7k|         else {
  160|  25.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  25.7k|         }
  162|  45.4k|         (void)m( result );
  163|  45.4k|         return result;
  164|  45.4k|      }
  165|  45.4k|   }
_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|  45.4k|      {
   73|  45.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|  45.4k|         else {
   84|  45.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  45.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  45.4k|      }
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|  45.4k|      {
   59|  45.4k|         return Rule::match( in );
   60|  45.4k|      }
_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|  19.7k|   {
  104|  19.7k|      if constexpr( !Control< Rule >::enable ) {
  105|  19.7k|         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|  19.7k|   }
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|  19.7k|      {
   44|  19.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  19.7k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  19.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  19.7k|      else {
  108|  19.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  19.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  19.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|  19.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|  19.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|  19.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|  19.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|  19.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|  19.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  19.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  19.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  19.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|  19.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  19.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  19.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|  19.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  19.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  19.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  19.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  19.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 19.6k, False: 21]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  19.6k|            else if constexpr( has_apply0_bool ) {
  153|  19.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  19.6k|            }
  155|  19.6k|         }
  156|  19.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 19.6k, False: 21]
  ------------------
  157|  19.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  19.6k|         }
  159|     21|         else {
  160|     21|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     21|         }
  162|  19.7k|         (void)m( result );
  163|  19.7k|         return result;
  164|  19.7k|      }
  165|  19.7k|   }
_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|  19.7k|      {
   73|  19.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|  19.7k|         else {
   84|  19.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  19.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  19.7k|      }
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|  19.7k|      {
   44|  19.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  19.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_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.3k, False: 21]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.3k|            else if constexpr( has_apply0_bool ) {
  153|  39.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  39.3k|            }
  155|  39.3k|         }
  156|  39.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 39.3k, False: 21]
  ------------------
  157|  39.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  39.3k|         }
  159|     21|         else {
  160|     21|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     21|         }
  162|  39.4k|         (void)m( result );
  163|  39.4k|         return result;
  164|  39.4k|      }
  165|  39.4k|   }
_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|  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_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  39.4k|      {
   59|  39.4k|         return Rule::match( in );
   60|  39.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  25.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  25.7k|      else {
  108|  25.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  25.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  25.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|  25.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|  25.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|  25.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|  25.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|  25.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|  25.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  25.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  25.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  25.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|  25.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  25.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  25.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|  25.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  25.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  25.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  25.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  25.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.1k, False: 15.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|  10.1k|            else if constexpr( has_apply0_bool ) {
  153|  10.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.1k|            }
  155|  10.1k|         }
  156|  25.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.1k, False: 15.5k]
  ------------------
  157|  10.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.1k|         }
  159|  15.5k|         else {
  160|  15.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  15.5k|         }
  162|  25.7k|         (void)m( result );
  163|  25.7k|         return result;
  164|  25.7k|      }
  165|  25.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|  25.7k|      {
   73|  25.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|  25.7k|         else {
   84|  25.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  25.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  25.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|  25.7k|      {
   44|  25.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  25.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  38.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  38.6k|      else {
  108|  38.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  38.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  38.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|  38.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|  38.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|  38.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|  38.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|  38.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|  38.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  38.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  38.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  38.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|  38.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  38.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  38.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|  38.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  38.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  38.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  38.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  38.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14.8k, False: 23.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|  14.8k|            else if constexpr( has_apply0_bool ) {
  153|  14.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  14.8k|            }
  155|  14.8k|         }
  156|  38.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14.8k, False: 23.7k]
  ------------------
  157|  14.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  14.8k|         }
  159|  23.7k|         else {
  160|  23.7k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  23.7k|         }
  162|  38.6k|         (void)m( result );
  163|  38.6k|         return result;
  164|  38.6k|      }
  165|  38.6k|   }
_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|  38.6k|      {
   73|  38.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|  38.6k|         else {
   84|  38.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  38.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  38.6k|      }
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|  38.6k|      {
   59|  38.6k|         return Rule::match( in );
   60|  38.6k|      }
_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|  10.1k|   {
  104|  10.1k|      if constexpr( !Control< Rule >::enable ) {
  105|  10.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|  10.1k|   }
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|  10.1k|      {
   44|  10.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.1k|      }
_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|  10.1k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  10.1k|      else {
  108|  10.1k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  10.1k|         using iterator_t = typename ParseInput::iterator_t;
  111|  10.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|  10.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|  10.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|  10.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|  10.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|  10.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|  10.1k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  10.1k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  10.1k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  10.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|  10.1k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  10.1k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  10.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|  10.1k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  10.1k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  10.1k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  10.1k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  10.1k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 10.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|  10.1k|            else if constexpr( has_apply0_bool ) {
  153|  10.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  10.1k|            }
  155|  10.1k|         }
  156|  10.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 10.1k, False: 0]
  ------------------
  157|  10.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  10.1k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  10.1k|         (void)m( result );
  163|  10.1k|         return result;
  164|  10.1k|      }
  165|  10.1k|   }
_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|  10.1k|      {
   73|  10.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|  10.1k|         else {
   84|  10.1k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  10.1k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  10.1k|      }
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|  10.1k|      {
   44|  10.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.1k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  15.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  15.5k|      else {
  108|  15.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.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|  15.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|  15.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|  15.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|  15.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|  15.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|  15.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.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|  15.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.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|  15.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  15.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 14.9k, False: 609]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.9k|            else if constexpr( has_apply0_bool ) {
  153|  14.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  14.9k|            }
  155|  14.9k|         }
  156|  15.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 14.9k, False: 609]
  ------------------
  157|  14.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  14.9k|         }
  159|    609|         else {
  160|    609|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    609|         }
  162|  15.5k|         (void)m( result );
  163|  15.5k|         return result;
  164|  15.5k|      }
  165|  15.5k|   }
_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|  15.5k|      {
   73|  15.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|  15.5k|         else {
   84|  15.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.5k|      }
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|  15.5k|      {
   59|  15.5k|         return Rule::match( in );
   60|  15.5k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    609|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    609|      else {
  108|    609|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    609|         using iterator_t = typename ParseInput::iterator_t;
  111|    609|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    609|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    609|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    609|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    609|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    609|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    609|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    609|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    609|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    609|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    609|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    609|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    609|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    609|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    609|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    609|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    609|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    609|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 558, 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|    558|            else if constexpr( has_apply0_bool ) {
  153|    558|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    558|            }
  155|    558|         }
  156|    609|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 558, False: 51]
  ------------------
  157|    558|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    558|         }
  159|     51|         else {
  160|     51|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     51|         }
  162|    609|         (void)m( result );
  163|    609|         return result;
  164|    609|      }
  165|    609|   }
_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|    609|      {
   73|    609|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    609|         else {
   84|    609|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    609|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    609|      }
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|    609|      {
   59|    609|         return Rule::match( in );
   60|    609|      }
_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.72M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.72M|      else {
  108|  6.72M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.72M|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.72M|         constexpr bool has_apply_void = enable_action && internal::has_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.72M|         constexpr bool has_apply_bool = enable_action && internal::has_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.72M|         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.72M|         constexpr bool has_apply0_void = enable_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.72M|         constexpr bool has_apply0_bool = enable_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.72M|         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.72M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.72M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.72M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.72M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.72M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.72M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.72M|         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.72M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.72M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.72M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.72M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.72M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.72M, False: 183]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.72M|            else if constexpr( has_apply0_bool ) {
  153|  6.72M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.72M|            }
  155|  6.72M|         }
  156|  6.72M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.72M, False: 183]
  ------------------
  157|  6.72M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.72M|         }
  159|    183|         else {
  160|    183|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    183|         }
  162|  6.72M|         (void)m( result );
  163|  6.72M|         return result;
  164|  6.72M|      }
  165|  6.72M|   }
_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.72M|      {
   73|  6.72M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.72M|         else {
   84|  6.72M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.72M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.72M|      }
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.72M|      {
   59|  6.72M|         return Rule::match( in );
   60|  6.72M|      }
_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|  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: 4.44k, False: 24.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|  4.44k|            else if constexpr( has_apply0_bool ) {
  153|  4.44k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.44k|            }
  155|  4.44k|         }
  156|  29.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.44k, False: 24.6k]
  ------------------
  157|  4.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.44k|         }
  159|  24.6k|         else {
  160|  24.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  24.6k|         }
  162|  29.1k|         (void)m( result );
  163|  29.1k|         return result;
  164|  29.1k|      }
  165|  29.1k|   }
_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|  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_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|  29.1k|      {
   44|  29.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.1k|      }
_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|  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: 4.44k, False: 24.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|  4.44k|            else if constexpr( has_apply0_bool ) {
  153|  4.44k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.44k|            }
  155|  4.44k|         }
  156|  29.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.44k, False: 24.6k]
  ------------------
  157|  4.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.44k|         }
  159|  24.6k|         else {
  160|  24.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  24.6k|         }
  162|  29.1k|         (void)m( result );
  163|  29.1k|         return result;
  164|  29.1k|      }
  165|  29.1k|   }
_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|  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_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|  29.1k|      {
   44|  29.1k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  29.1k|      }
_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|  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): [True: 0, Folded]
  ------------------
  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): [True: 29.1k, Folded]
  |  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): [True: 29.1k, Folded]
  |  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: 4.85k, False: 24.2k]
  ------------------
  143|  4.85k|            if constexpr( has_apply_void ) {
  144|  4.85k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.85k|         }
  156|  29.1k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.85k, False: 24.2k]
  ------------------
  157|  4.85k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.85k|         }
  159|  24.2k|         else {
  160|  24.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  24.2k|         }
  162|  29.1k|         (void)m( result );
  163|  29.1k|         return result;
  164|  29.1k|      }
  165|  29.1k|   }
_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|  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_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|  29.1k|      {
   59|  29.1k|         return Rule::match( in );
   60|  29.1k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|   187k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   187k|      else {
  108|   187k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   187k|         using iterator_t = typename ParseInput::iterator_t;
  111|   187k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   187k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   187k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   187k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   187k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   187k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   187k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   187k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   187k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   187k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   187k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   187k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   187k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   187k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   187k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   187k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   187k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   187k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 185k, False: 1.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|   185k|            else if constexpr( has_apply0_bool ) {
  153|   185k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   185k|            }
  155|   185k|         }
  156|   187k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 185k, False: 1.98k]
  ------------------
  157|   185k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   185k|         }
  159|  1.98k|         else {
  160|  1.98k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.98k|         }
  162|   187k|         (void)m( result );
  163|   187k|         return result;
  164|   187k|      }
  165|   187k|   }
_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|   187k|      {
   73|   187k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   187k|         else {
   84|   187k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   187k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   187k|      }
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|   187k|      {
   44|   187k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   187k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   187k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   187k|      else {
  108|   187k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   187k|         using iterator_t = typename ParseInput::iterator_t;
  111|   187k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   187k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   187k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   187k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   187k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   187k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   187k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   187k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   187k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   187k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   187k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   187k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   187k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   187k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   187k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   187k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   187k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   187k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 185k, False: 1.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|   185k|            else if constexpr( has_apply0_bool ) {
  153|   185k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   185k|            }
  155|   185k|         }
  156|   187k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 185k, False: 1.98k]
  ------------------
  157|   185k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   185k|         }
  159|  1.98k|         else {
  160|  1.98k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.98k|         }
  162|   187k|         (void)m( result );
  163|   187k|         return result;
  164|   187k|      }
  165|   187k|   }
_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|   187k|      {
   73|   187k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   187k|         else {
   84|   187k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   187k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   187k|      }
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|   187k|      {
   59|   187k|         return Rule::match( in );
   60|   187k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  1.78M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.78M|      else {
  108|  1.78M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.78M|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.78M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.78M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.78M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.78M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.78M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.78M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.78M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.78M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.78M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.78M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.59M, False: 192k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.59M|            else if constexpr( has_apply0_bool ) {
  153|  1.59M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.59M|            }
  155|  1.59M|         }
  156|  1.78M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.59M, False: 192k]
  ------------------
  157|  1.59M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.59M|         }
  159|   192k|         else {
  160|   192k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   192k|         }
  162|  1.78M|         (void)m( result );
  163|  1.78M|         return result;
  164|  1.78M|      }
  165|  1.78M|   }
_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.78M|      {
   73|  1.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|  1.78M|         else {
   84|  1.78M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.78M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.78M|      }
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.78M|      {
   59|  1.78M|         return Rule::match( in );
   60|  1.78M|      }
_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|  4.84k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.84k|      else {
  108|  4.84k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.84k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.84k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.84k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.84k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.84k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.84k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.84k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.84k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.84k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.84k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.84k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.44k, False: 401]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.44k|            else if constexpr( has_apply0_bool ) {
  153|  4.44k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.44k|            }
  155|  4.44k|         }
  156|  4.84k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.44k, False: 401]
  ------------------
  157|  4.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.44k|         }
  159|    401|         else {
  160|    401|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    401|         }
  162|  4.84k|         (void)m( result );
  163|  4.84k|         return result;
  164|  4.84k|      }
  165|  4.84k|   }
_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|  4.84k|      {
   73|  4.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|  4.84k|         else {
   84|  4.84k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.84k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.84k|      }
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|  4.84k|      {
   44|  4.84k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.84k|      }
_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|  4.84k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.84k|      else {
  108|  4.84k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.84k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.84k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.84k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.84k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.84k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.84k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.84k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.84k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.84k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.84k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.84k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.39k, False: 1.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|  3.39k|            else if constexpr( has_apply0_bool ) {
  153|  3.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.39k|            }
  155|  3.39k|         }
  156|  4.84k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.39k, False: 1.45k]
  ------------------
  157|  3.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.39k|         }
  159|  1.45k|         else {
  160|  1.45k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.45k|         }
  162|  4.84k|         (void)m( result );
  163|  4.84k|         return result;
  164|  4.84k|      }
  165|  4.84k|   }
_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|  4.84k|      {
   73|  4.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|  4.84k|         else {
   84|  4.84k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.84k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.84k|      }
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|  4.84k|      {
   44|  4.84k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.84k|      }
_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|  4.84k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.84k|      else {
  108|  4.84k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.84k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.84k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.84k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.84k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.84k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.84k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.84k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.84k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.84k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.84k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.84k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.84k, 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.84k|            else if constexpr( has_apply0_bool ) {
  153|  4.84k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.84k|            }
  155|  4.84k|         }
  156|  4.84k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.84k, False: 0]
  ------------------
  157|  4.84k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.84k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.84k|         (void)m( result );
  163|  4.84k|         return result;
  164|  4.84k|      }
  165|  4.84k|   }
_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|  4.84k|      {
   73|  4.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|  4.84k|         else {
   84|  4.84k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.84k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.84k|      }
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|  4.84k|      {
   44|  4.84k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.84k|      }
_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|  4.84k|   {
  104|  4.84k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.84k|         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.84k|   }
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|  4.84k|      {
   44|  4.84k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.84k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.84k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.84k|      else {
  108|  4.84k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.84k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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): [True: 0, Folded]
  ------------------
  112|  4.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|  4.84k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.84k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.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|  4.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|  4.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|  4.84k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.84k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.84k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.84k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.84k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.84k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.84k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.84k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.84k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.84k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.84k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.23k, False: 1.61k]
  ------------------
  143|  3.23k|            if constexpr( has_apply_void ) {
  144|  3.23k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.23k|         }
  156|  4.84k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.23k, False: 1.61k]
  ------------------
  157|  3.23k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.23k|         }
  159|  1.61k|         else {
  160|  1.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.61k|         }
  162|  4.84k|         (void)m( result );
  163|  4.84k|         return result;
  164|  4.84k|      }
  165|  4.84k|   }
_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|  4.84k|      {
   73|  4.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|  4.84k|         else {
   84|  4.84k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.84k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.84k|      }
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|  4.84k|      {
   44|  4.84k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.84k|      }
_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|  4.84k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.84k|      else {
  108|  4.84k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.84k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.84k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.84k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.84k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.84k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.84k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.84k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.84k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.84k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.84k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.84k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 540, False: 4.30k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    540|            else if constexpr( has_apply0_bool ) {
  153|    540|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    540|            }
  155|    540|         }
  156|  4.84k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 540, False: 4.30k]
  ------------------
  157|    540|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    540|         }
  159|  4.30k|         else {
  160|  4.30k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.30k|         }
  162|  4.84k|         (void)m( result );
  163|  4.84k|         return result;
  164|  4.84k|      }
  165|  4.84k|   }
_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|  4.84k|      {
   73|  4.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|  4.84k|         else {
   84|  4.84k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.84k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.84k|      }
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|  4.84k|      {
   59|  4.84k|         return Rule::match( in );
   60|  4.84k|      }
_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|  4.30k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.30k|      else {
  108|  4.30k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.30k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.30k|         constexpr bool has_apply_void = enable_action && internal::has_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.30k|         constexpr bool has_apply_bool = enable_action && internal::has_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.30k|         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.30k|         constexpr bool has_apply0_void = enable_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.30k|         constexpr bool has_apply0_bool = enable_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.30k|         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.30k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.30k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.30k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.30k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.30k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.30k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.30k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.30k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.30k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.30k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.30k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.30k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 272, 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|    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|  4.30k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 272, False: 4.03k]
  ------------------
  157|    272|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    272|         }
  159|  4.03k|         else {
  160|  4.03k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.03k|         }
  162|  4.30k|         (void)m( result );
  163|  4.30k|         return result;
  164|  4.30k|      }
  165|  4.30k|   }
_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|  4.30k|      {
   73|  4.30k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.30k|         else {
   84|  4.30k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.30k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.30k|      }
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|  4.30k|      {
   59|  4.30k|         return Rule::match( in );
   60|  4.30k|      }
_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|  4.03k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.03k|      else {
  108|  4.03k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.03k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.03k|         constexpr bool has_apply_void = enable_action && internal::has_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.03k|         constexpr bool has_apply_bool = enable_action && internal::has_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.03k|         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.03k|         constexpr bool has_apply0_void = enable_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.03k|         constexpr bool has_apply0_bool = enable_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.03k|         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.03k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.03k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.03k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.03k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.03k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.03k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.03k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.03k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.03k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.03k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.03k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.03k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 313, False: 3.72k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    313|            else if constexpr( has_apply0_bool ) {
  153|    313|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    313|            }
  155|    313|         }
  156|  4.03k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 313, False: 3.72k]
  ------------------
  157|    313|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    313|         }
  159|  3.72k|         else {
  160|  3.72k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.72k|         }
  162|  4.03k|         (void)m( result );
  163|  4.03k|         return result;
  164|  4.03k|      }
  165|  4.03k|   }
_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|  4.03k|      {
   73|  4.03k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.03k|         else {
   84|  4.03k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.03k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.03k|      }
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|  4.03k|      {
   59|  4.03k|         return Rule::match( in );
   60|  4.03k|      }
_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|  3.72k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.72k|      else {
  108|  3.72k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.72k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.72k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.72k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.72k|         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.72k|         constexpr bool has_apply0_void = enable_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.72k|         constexpr bool has_apply0_bool = enable_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.72k|         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.72k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.72k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.72k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.72k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.72k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.72k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.72k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.72k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.72k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.72k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.72k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.72k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 635, False: 3.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|    635|            else if constexpr( has_apply0_bool ) {
  153|    635|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    635|            }
  155|    635|         }
  156|  3.72k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 635, False: 3.08k]
  ------------------
  157|    635|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    635|         }
  159|  3.08k|         else {
  160|  3.08k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.08k|         }
  162|  3.72k|         (void)m( result );
  163|  3.72k|         return result;
  164|  3.72k|      }
  165|  3.72k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  3.72k|      {
   73|  3.72k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.72k|         else {
   84|  3.72k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.72k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.72k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.72k|      {
   59|  3.72k|         return Rule::match( in );
   60|  3.72k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  3.08k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.08k|      else {
  108|  3.08k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.08k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.08k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.08k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.08k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.08k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.08k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.08k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.08k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.08k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.08k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.08k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 376, False: 2.71k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    376|            else if constexpr( has_apply0_bool ) {
  153|    376|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    376|            }
  155|    376|         }
  156|  3.08k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 376, False: 2.71k]
  ------------------
  157|    376|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    376|         }
  159|  2.71k|         else {
  160|  2.71k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.71k|         }
  162|  3.08k|         (void)m( result );
  163|  3.08k|         return result;
  164|  3.08k|      }
  165|  3.08k|   }
_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|  3.08k|      {
   73|  3.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|  3.08k|         else {
   84|  3.08k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.08k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.08k|      }
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|  3.08k|      {
   59|  3.08k|         return Rule::match( in );
   60|  3.08k|      }
_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|  2.71k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.71k|      else {
  108|  2.71k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.71k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.71k|         constexpr bool has_apply_void = enable_action && internal::has_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.71k|         constexpr bool has_apply_bool = enable_action && internal::has_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.71k|         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.71k|         constexpr bool has_apply0_void = enable_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.71k|         constexpr bool has_apply0_bool = enable_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.71k|         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.71k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.71k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.71k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.71k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.71k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.71k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.71k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.71k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.71k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.71k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.71k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.71k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.10k, False: 1.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|  1.10k|            else if constexpr( has_apply0_bool ) {
  153|  1.10k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.10k|            }
  155|  1.10k|         }
  156|  2.71k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.10k, False: 1.61k]
  ------------------
  157|  1.10k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.10k|         }
  159|  1.61k|         else {
  160|  1.61k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.61k|         }
  162|  2.71k|         (void)m( result );
  163|  2.71k|         return result;
  164|  2.71k|      }
  165|  2.71k|   }
_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|  2.71k|      {
   73|  2.71k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.71k|         else {
   84|  2.71k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.71k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.71k|      }
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|  2.71k|      {
   59|  2.71k|         return Rule::match( in );
   60|  2.71k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.84k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.84k|      else {
  108|  4.84k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.84k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.84k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.84k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.84k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.84k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.84k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.84k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.84k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.84k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.84k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.84k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.61k, 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|  3.61k|            else if constexpr( has_apply0_bool ) {
  153|  3.61k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.61k|            }
  155|  3.61k|         }
  156|  4.84k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.61k, False: 1.23k]
  ------------------
  157|  3.61k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.61k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|  4.84k|         (void)m( result );
  163|  4.84k|         return result;
  164|  4.84k|      }
  165|  4.84k|   }
_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|  4.84k|      {
   73|  4.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|  4.84k|         else {
   84|  4.84k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.84k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.84k|      }
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|  4.84k|      {
   59|  4.84k|         return Rule::match( in );
   60|  4.84k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  7.18k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.18k|      else {
  108|  7.18k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.18k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.18k|         constexpr bool has_apply_void = enable_action && internal::has_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.18k|         constexpr bool has_apply_bool = enable_action && internal::has_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.18k|         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.18k|         constexpr bool has_apply0_void = enable_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.18k|         constexpr bool has_apply0_bool = enable_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.18k|         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.18k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.18k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.18k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.18k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.18k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.18k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.18k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  7.18k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.18k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.18k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.18k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.18k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.18k, 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|  7.18k|            else if constexpr( has_apply0_bool ) {
  153|  7.18k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.18k|            }
  155|  7.18k|         }
  156|  7.18k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.18k, False: 0]
  ------------------
  157|  7.18k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.18k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  7.18k|         (void)m( result );
  163|  7.18k|         return result;
  164|  7.18k|      }
  165|  7.18k|   }
_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|  7.18k|      {
   73|  7.18k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.18k|         else {
   84|  7.18k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.18k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.18k|      }
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|  7.18k|      {
   44|  7.18k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.18k|      }
_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|  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: 3.56k, False: 52]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.56k|            else if constexpr( has_apply0_bool ) {
  153|  3.56k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.56k|            }
  155|  3.56k|         }
  156|  3.61k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.56k, False: 52]
  ------------------
  157|  3.56k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.56k|         }
  159|     52|         else {
  160|     52|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     52|         }
  162|  3.61k|         (void)m( result );
  163|  3.61k|         return result;
  164|  3.61k|      }
  165|  3.61k|   }
_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|  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_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|  3.61k|      {
   44|  3.61k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.61k|      }
_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|  3.56k|   {
  104|  3.56k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.56k|         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.56k|   }
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|  3.56k|      {
   44|  3.56k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.56k|      }
_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|   179k|   {
  104|   179k|      if constexpr( !Control< Rule >::enable ) {
  105|   179k|         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|   179k|   }
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|   179k|      {
   44|   179k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   179k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  3.56k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.56k|      else {
  108|  3.56k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.56k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.56k|         constexpr bool has_apply_void = enable_action && internal::has_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.56k|         constexpr bool has_apply_bool = enable_action && internal::has_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.56k|         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.56k|         constexpr bool has_apply0_void = enable_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.56k|         constexpr bool has_apply0_bool = enable_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.56k|         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.56k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.56k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.56k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.56k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.56k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.56k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.56k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.56k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.56k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.56k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.56k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.56k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.39k, False: 175]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.39k|            else if constexpr( has_apply0_bool ) {
  153|  3.39k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.39k|            }
  155|  3.39k|         }
  156|  3.56k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.39k, False: 175]
  ------------------
  157|  3.39k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.39k|         }
  159|    175|         else {
  160|    175|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    175|         }
  162|  3.56k|         (void)m( result );
  163|  3.56k|         return result;
  164|  3.56k|      }
  165|  3.56k|   }
_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|  3.56k|      {
   73|  3.56k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.56k|         else {
   84|  3.56k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.56k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.56k|      }
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|  3.56k|      {
   59|  3.56k|         return Rule::match( in );
   60|  3.56k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15interface_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   182k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   182k|      else {
  108|   182k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   182k|         using iterator_t = typename ParseInput::iterator_t;
  111|   182k|         constexpr bool has_apply_void = 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|   182k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   182k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 182k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   182k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   182k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   182k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   182k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   182k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   182k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   182k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   182k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   182k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   182k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   182k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 182k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   182k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   182k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   182k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   182k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 180k, False: 2.06k]
  ------------------
  143|   180k|            if constexpr( has_apply_void ) {
  144|   180k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   180k|         }
  156|   182k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 180k, False: 2.06k]
  ------------------
  157|   180k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   180k|         }
  159|  2.06k|         else {
  160|  2.06k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.06k|         }
  162|   182k|         (void)m( result );
  163|   182k|         return result;
  164|   182k|      }
  165|   182k|   }
_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|   182k|      {
   73|   182k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   182k|         else {
   84|   182k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   182k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   182k|      }
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|   182k|      {
   44|   182k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   182k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   182k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   182k|      else {
  108|   182k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   182k|         using iterator_t = typename ParseInput::iterator_t;
  111|   182k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   182k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   182k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   182k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   182k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   182k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   182k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   182k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   182k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   182k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   182k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   182k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   182k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   182k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   182k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   182k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   182k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   182k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 180k, 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|   180k|            else if constexpr( has_apply0_bool ) {
  153|   180k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   180k|            }
  155|   180k|         }
  156|   182k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 180k, False: 1.96k]
  ------------------
  157|   180k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   180k|         }
  159|  1.96k|         else {
  160|  1.96k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.96k|         }
  162|   182k|         (void)m( result );
  163|   182k|         return result;
  164|   182k|      }
  165|   182k|   }
_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|   182k|      {
   73|   182k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   182k|         else {
   84|   182k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   182k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   182k|      }
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|   182k|      {
   44|   182k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   182k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   914k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   914k|      else {
  108|   914k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   914k|         using iterator_t = typename ParseInput::iterator_t;
  111|   914k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   914k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   914k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   914k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   914k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   914k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   914k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   914k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   914k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   914k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   914k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   914k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   914k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   914k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   914k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   914k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   914k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   914k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 740k, 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|   740k|            else if constexpr( has_apply0_bool ) {
  153|   740k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   740k|            }
  155|   740k|         }
  156|   914k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 740k, False: 173k]
  ------------------
  157|   740k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   740k|         }
  159|   173k|         else {
  160|   173k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   173k|         }
  162|   914k|         (void)m( result );
  163|   914k|         return result;
  164|   914k|      }
  165|   914k|   }
_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|   914k|      {
   73|   914k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   914k|         else {
   84|   914k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   914k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   914k|      }
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|   914k|      {
   59|   914k|         return Rule::match( in );
   60|   914k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc58EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   361k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   361k|      else {
  108|   361k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   361k|         using iterator_t = typename ParseInput::iterator_t;
  111|   361k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   361k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   361k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   361k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   361k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   361k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   361k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   361k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   361k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   361k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   361k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   361k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   361k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   361k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   361k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   361k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   361k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   361k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 361k, False: 52]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   361k|            else if constexpr( has_apply0_bool ) {
  153|   361k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   361k|            }
  155|   361k|         }
  156|   361k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 361k, False: 52]
  ------------------
  157|   361k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   361k|         }
  159|     52|         else {
  160|     52|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     52|         }
  162|   361k|         (void)m( result );
  163|   361k|         return result;
  164|   361k|      }
  165|   361k|   }
_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|   361k|      {
   73|   361k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   361k|         else {
   84|   361k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   361k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   361k|      }
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|   361k|      {
   59|   361k|         return Rule::match( in );
   60|   361k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14hex2orAsteriskELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   361k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   361k|      else {
  108|   361k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   361k|         using iterator_t = typename ParseInput::iterator_t;
  111|   361k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   361k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   361k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   361k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   361k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   361k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   361k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   361k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   361k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   361k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   361k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   361k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   361k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   361k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   361k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   361k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   361k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   361k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 361k, False: 46]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   361k|            else if constexpr( has_apply0_bool ) {
  153|   361k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   361k|            }
  155|   361k|         }
  156|   361k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 361k, False: 46]
  ------------------
  157|   361k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   361k|         }
  159|     46|         else {
  160|     46|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     46|         }
  162|   361k|         (void)m( result );
  163|   361k|         return result;
  164|   361k|      }
  165|   361k|   }
_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|   361k|      {
   73|   361k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   361k|         else {
   84|   361k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   361k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   361k|      }
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|   361k|      {
   44|   361k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   361k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser4hex2ELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   361k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   361k|      else {
  108|   361k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   361k|         using iterator_t = typename ParseInput::iterator_t;
  111|   361k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   361k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   361k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   361k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   361k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   361k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   361k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   361k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   361k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   361k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   361k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   361k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   361k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   361k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   361k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   361k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   361k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   361k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 189k, False: 171k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   189k|            else if constexpr( has_apply0_bool ) {
  153|   189k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   189k|            }
  155|   189k|         }
  156|   361k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 189k, False: 171k]
  ------------------
  157|   189k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   189k|         }
  159|   171k|         else {
  160|   171k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   171k|         }
  162|   361k|         (void)m( result );
  163|   361k|         return result;
  164|   361k|      }
  165|   361k|   }
_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|   361k|      {
   73|   361k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   361k|         else {
   84|   361k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   361k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   361k|      }
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|   361k|      {
   44|   361k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   361k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc42EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   171k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   171k|      else {
  108|   171k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   171k|         using iterator_t = typename ParseInput::iterator_t;
  111|   171k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   171k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   171k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   171k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   171k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   171k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   171k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   171k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   171k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   171k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   171k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   171k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   171k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   171k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   171k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   171k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   171k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   171k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 171k, False: 46]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   171k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 171k, False: 46]
  ------------------
  157|   171k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   171k|         }
  159|     46|         else {
  160|     46|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     46|         }
  162|   171k|         (void)m( result );
  163|   171k|         return result;
  164|   171k|      }
  165|   171k|   }
_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|   171k|      {
   73|   171k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   171k|         else {
   84|   171k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   171k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   171k|      }
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|   171k|      {
   59|   171k|         return Rule::match( in );
   60|   171k|      }
_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|  24.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  24.6k|      else {
  108|  24.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  24.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  24.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|  24.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|  24.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|  24.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|  24.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|  24.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|  24.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  24.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  24.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  24.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|  24.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  24.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  24.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|  24.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  24.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  24.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  24.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  24.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.73k, False: 20.9k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  24.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.73k, False: 20.9k]
  ------------------
  157|  3.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.73k|         }
  159|  20.9k|         else {
  160|  20.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  20.9k|         }
  162|  24.6k|         (void)m( result );
  163|  24.6k|         return result;
  164|  24.6k|      }
  165|  24.6k|   }
_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|  24.6k|      {
   73|  24.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|  24.6k|         else {
   84|  24.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  24.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  24.6k|      }
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|  24.6k|      {
   44|  24.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  24.6k|      }
_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|  24.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  24.6k|      else {
  108|  24.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  24.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  24.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|  24.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|  24.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|  24.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|  24.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|  24.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|  24.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  24.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  24.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  24.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|  24.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  24.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  24.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|  24.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  24.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  24.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  24.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  24.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.73k, False: 20.9k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  24.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.73k, False: 20.9k]
  ------------------
  157|  3.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.73k|         }
  159|  20.9k|         else {
  160|  20.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  20.9k|         }
  162|  24.6k|         (void)m( result );
  163|  24.6k|         return result;
  164|  24.6k|      }
  165|  24.6k|   }
_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|  24.6k|      {
   73|  24.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|  24.6k|         else {
   84|  24.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  24.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  24.6k|      }
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|  24.6k|      {
   44|  24.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  24.6k|      }
_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|  24.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  24.6k|      else {
  108|  24.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  24.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  24.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): [True: 0, Folded]
  ------------------
  112|  24.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|  24.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 24.6k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  24.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|  24.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|  24.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|  24.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  24.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  24.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  24.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|  24.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  24.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  24.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|  24.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 24.6k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  24.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  24.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  24.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  24.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.31k, False: 20.3k]
  ------------------
  143|  4.31k|            if constexpr( has_apply_void ) {
  144|  4.31k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.31k|         }
  156|  24.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.31k, False: 20.3k]
  ------------------
  157|  4.31k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.31k|         }
  159|  20.3k|         else {
  160|  20.3k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  20.3k|         }
  162|  24.6k|         (void)m( result );
  163|  24.6k|         return result;
  164|  24.6k|      }
  165|  24.6k|   }
_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|  24.6k|      {
   73|  24.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|  24.6k|         else {
   84|  24.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  24.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  24.6k|      }
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|  24.6k|      {
   59|  24.6k|         return Rule::match( in );
   60|  24.6k|      }
_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|  14.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  14.2k|      else {
  108|  14.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  14.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  14.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|  14.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|  14.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|  14.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|  14.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|  14.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|  14.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  14.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  14.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  14.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|  14.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  14.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  14.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|  14.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  14.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  14.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  14.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  14.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 11.2k, False: 3.01k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  11.2k|            else if constexpr( has_apply0_bool ) {
  153|  11.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  11.2k|            }
  155|  11.2k|         }
  156|  14.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 11.2k, False: 3.01k]
  ------------------
  157|  11.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  11.2k|         }
  159|  3.01k|         else {
  160|  3.01k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.01k|         }
  162|  14.2k|         (void)m( result );
  163|  14.2k|         return result;
  164|  14.2k|      }
  165|  14.2k|   }
_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|  14.2k|      {
   73|  14.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|  14.2k|         else {
   84|  14.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  14.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  14.2k|      }
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|  14.2k|      {
   44|  14.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  14.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  14.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  14.2k|      else {
  108|  14.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  14.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  14.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|  14.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|  14.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|  14.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|  14.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|  14.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|  14.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  14.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  14.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  14.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|  14.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  14.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  14.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|  14.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  14.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  14.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  14.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  14.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 11.2k, False: 3.01k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  11.2k|            else if constexpr( has_apply0_bool ) {
  153|  11.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  11.2k|            }
  155|  11.2k|         }
  156|  14.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 11.2k, False: 3.01k]
  ------------------
  157|  11.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  11.2k|         }
  159|  3.01k|         else {
  160|  3.01k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.01k|         }
  162|  14.2k|         (void)m( result );
  163|  14.2k|         return result;
  164|  14.2k|      }
  165|  14.2k|   }
_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|  14.2k|      {
   73|  14.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|  14.2k|         else {
   84|  14.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  14.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  14.2k|      }
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|  14.2k|      {
   59|  14.2k|         return Rule::match( in );
   60|  14.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  24.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  24.0k|      else {
  108|  24.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  24.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  24.0k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  24.0k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  24.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|  24.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|  24.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|  24.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|  24.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  24.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  24.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  24.0k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|  24.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  24.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  24.0k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  24.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  24.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  24.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  24.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  24.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.93k, False: 18.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|  5.93k|            else if constexpr( has_apply0_bool ) {
  153|  5.93k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.93k|            }
  155|  5.93k|         }
  156|  24.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.93k, False: 18.1k]
  ------------------
  157|  5.93k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.93k|         }
  159|  18.1k|         else {
  160|  18.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  18.1k|         }
  162|  24.0k|         (void)m( result );
  163|  24.0k|         return result;
  164|  24.0k|      }
  165|  24.0k|   }
_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|  24.0k|      {
   73|  24.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|  24.0k|         else {
   84|  24.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  24.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  24.0k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  24.0k|      {
   59|  24.0k|         return Rule::match( in );
   60|  24.0k|      }
_ZN3tao5pegtl5matchINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  4.30k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.30k|      else {
  108|  4.30k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.30k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.30k|         constexpr bool has_apply_void = enable_action && internal::has_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.30k|         constexpr bool has_apply_bool = enable_action && internal::has_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.30k|         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.30k|         constexpr bool has_apply0_void = enable_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.30k|         constexpr bool has_apply0_bool = enable_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.30k|         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.30k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.30k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.30k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.30k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.30k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.30k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.30k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.30k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.30k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.30k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.30k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.30k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.73k, False: 564]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  4.30k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.73k, False: 564]
  ------------------
  157|  3.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.73k|         }
  159|    564|         else {
  160|    564|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    564|         }
  162|  4.30k|         (void)m( result );
  163|  4.30k|         return result;
  164|  4.30k|      }
  165|  4.30k|   }
_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|  4.30k|      {
   73|  4.30k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.30k|         else {
   84|  4.30k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.30k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.30k|      }
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|  4.30k|      {
   44|  4.30k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.30k|      }
_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|  4.30k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.30k|      else {
  108|  4.30k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.30k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.30k|         constexpr bool has_apply_void = enable_action && internal::has_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.30k|         constexpr bool has_apply_bool = enable_action && internal::has_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.30k|         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.30k|         constexpr bool has_apply0_void = enable_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.30k|         constexpr bool has_apply0_bool = enable_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.30k|         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.30k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.30k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.30k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.30k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.30k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.30k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.30k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.30k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.30k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.30k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.30k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.30k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.31k, False: 992]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.31k|            else if constexpr( has_apply0_bool ) {
  153|  3.31k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.31k|            }
  155|  3.31k|         }
  156|  4.30k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.31k, False: 992]
  ------------------
  157|  3.31k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.31k|         }
  159|    992|         else {
  160|    992|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    992|         }
  162|  4.30k|         (void)m( result );
  163|  4.30k|         return result;
  164|  4.30k|      }
  165|  4.30k|   }
_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|  4.30k|      {
   73|  4.30k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.30k|         else {
   84|  4.30k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.30k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.30k|      }
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|  4.30k|      {
   44|  4.30k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.30k|      }
_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|  4.30k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.30k|      else {
  108|  4.30k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.30k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.30k|         constexpr bool has_apply_void = enable_action && internal::has_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.30k|         constexpr bool has_apply_bool = enable_action && internal::has_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.30k|         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.30k|         constexpr bool has_apply0_void = enable_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.30k|         constexpr bool has_apply0_bool = enable_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.30k|         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.30k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.30k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.30k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.30k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.30k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.30k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.30k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.30k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.30k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.30k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.30k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.30k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.30k, 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.30k|            else if constexpr( has_apply0_bool ) {
  153|  4.30k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.30k|            }
  155|  4.30k|         }
  156|  4.30k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.30k, False: 0]
  ------------------
  157|  4.30k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.30k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.30k|         (void)m( result );
  163|  4.30k|         return result;
  164|  4.30k|      }
  165|  4.30k|   }
_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|  4.30k|      {
   73|  4.30k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.30k|         else {
   84|  4.30k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.30k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.30k|      }
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|  4.30k|      {
   44|  4.30k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.30k|      }
_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|  4.30k|   {
  104|  4.30k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.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|  4.30k|   }
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|  4.30k|      {
   44|  4.30k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.30k|      }
_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|  4.30k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.30k|      else {
  108|  4.30k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.30k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.30k|         constexpr bool has_apply_void = 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.30k|         constexpr bool has_apply_bool = enable_action && internal::has_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.30k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.30k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.30k|         constexpr bool has_apply0_void = enable_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.30k|         constexpr bool has_apply0_bool = enable_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.30k|         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.30k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.30k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.30k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.30k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.30k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.30k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.30k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.30k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.30k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.30k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.30k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.30k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.30k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.38k, False: 2.91k]
  ------------------
  143|  1.38k|            if constexpr( has_apply_void ) {
  144|  1.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|  1.38k|         }
  156|  4.30k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.38k, False: 2.91k]
  ------------------
  157|  1.38k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.38k|         }
  159|  2.91k|         else {
  160|  2.91k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.91k|         }
  162|  4.30k|         (void)m( result );
  163|  4.30k|         return result;
  164|  4.30k|      }
  165|  4.30k|   }
_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|  4.30k|      {
   73|  4.30k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.30k|         else {
   84|  4.30k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.30k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.30k|      }
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|  4.30k|      {
   44|  4.30k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.30k|      }
_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|  4.30k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.30k|      else {
  108|  4.30k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.30k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.30k|         constexpr bool has_apply_void = enable_action && internal::has_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.30k|         constexpr bool has_apply_bool = enable_action && internal::has_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.30k|         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.30k|         constexpr bool has_apply0_void = enable_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.30k|         constexpr bool has_apply0_bool = enable_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.30k|         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.30k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.30k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.30k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.30k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.30k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.30k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.30k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.30k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.30k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.30k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.30k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.30k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 191, False: 4.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|    191|            else if constexpr( has_apply0_bool ) {
  153|    191|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    191|            }
  155|    191|         }
  156|  4.30k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 191, False: 4.11k]
  ------------------
  157|    191|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    191|         }
  159|  4.11k|         else {
  160|  4.11k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.11k|         }
  162|  4.30k|         (void)m( result );
  163|  4.30k|         return result;
  164|  4.30k|      }
  165|  4.30k|   }
_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|  4.30k|      {
   73|  4.30k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.30k|         else {
   84|  4.30k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.30k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.30k|      }
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|  4.30k|      {
   59|  4.30k|         return Rule::match( in );
   60|  4.30k|      }
_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|  4.11k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.11k|      else {
  108|  4.11k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.11k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.11k|         constexpr bool has_apply_void = enable_action && internal::has_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.11k|         constexpr bool has_apply_bool = enable_action && internal::has_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.11k|         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.11k|         constexpr bool has_apply0_void = enable_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.11k|         constexpr bool has_apply0_bool = enable_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.11k|         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.11k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.11k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.11k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.11k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.11k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.11k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.11k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.11k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.11k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.11k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.11k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.11k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 117, False: 3.99k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    117|            else if constexpr( has_apply0_bool ) {
  153|    117|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    117|            }
  155|    117|         }
  156|  4.11k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 117, False: 3.99k]
  ------------------
  157|    117|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    117|         }
  159|  3.99k|         else {
  160|  3.99k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.99k|         }
  162|  4.11k|         (void)m( result );
  163|  4.11k|         return result;
  164|  4.11k|      }
  165|  4.11k|   }
_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|  4.11k|      {
   73|  4.11k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.11k|         else {
   84|  4.11k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.11k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.11k|      }
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|  4.11k|      {
   59|  4.11k|         return Rule::match( in );
   60|  4.11k|      }
_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|  3.99k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.99k|      else {
  108|  3.99k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.99k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.99k|         constexpr bool has_apply_void = enable_action && internal::has_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.99k|         constexpr bool has_apply_bool = enable_action && internal::has_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.99k|         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.99k|         constexpr bool has_apply0_void = enable_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.99k|         constexpr bool has_apply0_bool = enable_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.99k|         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.99k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.99k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.99k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.99k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.99k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.99k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.99k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.99k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.99k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.99k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.99k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.99k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 198, False: 3.79k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.99k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 198, False: 3.79k]
  ------------------
  157|    198|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    198|         }
  159|  3.79k|         else {
  160|  3.79k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.79k|         }
  162|  3.99k|         (void)m( result );
  163|  3.99k|         return result;
  164|  3.99k|      }
  165|  3.99k|   }
_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|  3.99k|      {
   73|  3.99k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.99k|         else {
   84|  3.99k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.99k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.99k|      }
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|  3.99k|      {
   59|  3.99k|         return Rule::match( in );
   60|  3.99k|      }
_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|  3.79k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.79k|      else {
  108|  3.79k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.79k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.79k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.79k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.79k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.79k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.79k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.79k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.79k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.79k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.79k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.79k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 453, False: 3.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|    453|            else if constexpr( has_apply0_bool ) {
  153|    453|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    453|            }
  155|    453|         }
  156|  3.79k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 453, False: 3.34k]
  ------------------
  157|    453|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    453|         }
  159|  3.34k|         else {
  160|  3.34k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.34k|         }
  162|  3.79k|         (void)m( result );
  163|  3.79k|         return result;
  164|  3.79k|      }
  165|  3.79k|   }
_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|  3.79k|      {
   73|  3.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|  3.79k|         else {
   84|  3.79k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.79k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.79k|      }
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|  3.79k|      {
   59|  3.79k|         return Rule::match( in );
   60|  3.79k|      }
_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|  3.34k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.34k|      else {
  108|  3.34k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.34k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.34k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.34k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.34k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.34k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.34k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.34k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.34k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.34k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.34k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.34k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 226, False: 3.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|    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|  3.34k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 226, False: 3.11k]
  ------------------
  157|    226|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    226|         }
  159|  3.11k|         else {
  160|  3.11k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.11k|         }
  162|  3.34k|         (void)m( result );
  163|  3.34k|         return result;
  164|  3.34k|      }
  165|  3.34k|   }
_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|  3.34k|      {
   73|  3.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|  3.34k|         else {
   84|  3.34k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.34k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.34k|      }
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|  3.34k|      {
   59|  3.34k|         return Rule::match( in );
   60|  3.34k|      }
_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|  3.11k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.11k|      else {
  108|  3.11k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.11k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.11k|         constexpr bool has_apply_void = enable_action && internal::has_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.11k|         constexpr bool has_apply_bool = enable_action && internal::has_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.11k|         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.11k|         constexpr bool has_apply0_void = enable_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.11k|         constexpr bool has_apply0_bool = enable_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.11k|         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.11k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.11k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.11k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.11k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.11k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.11k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.11k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.11k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.11k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.11k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.11k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.11k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 204, False: 2.91k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    204|            else if constexpr( has_apply0_bool ) {
  153|    204|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    204|            }
  155|    204|         }
  156|  3.11k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 204, False: 2.91k]
  ------------------
  157|    204|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    204|         }
  159|  2.91k|         else {
  160|  2.91k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.91k|         }
  162|  3.11k|         (void)m( result );
  163|  3.11k|         return result;
  164|  3.11k|      }
  165|  3.11k|   }
_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|  3.11k|      {
   73|  3.11k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.11k|         else {
   84|  3.11k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.11k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.11k|      }
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|  3.11k|      {
   59|  3.11k|         return Rule::match( in );
   60|  3.11k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.30k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.30k|      else {
  108|  4.30k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.30k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.30k|         constexpr bool has_apply_void = enable_action && internal::has_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.30k|         constexpr bool has_apply_bool = enable_action && internal::has_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.30k|         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.30k|         constexpr bool has_apply0_void = enable_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.30k|         constexpr bool has_apply0_bool = enable_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.30k|         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.30k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.30k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.30k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.30k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.30k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.30k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.30k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  4.30k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.30k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.30k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.30k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.30k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.50k, False: 794]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.50k|            else if constexpr( has_apply0_bool ) {
  153|  3.50k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.50k|            }
  155|  3.50k|         }
  156|  4.30k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.50k, False: 794]
  ------------------
  157|  3.50k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.50k|         }
  159|    794|         else {
  160|    794|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    794|         }
  162|  4.30k|         (void)m( result );
  163|  4.30k|         return result;
  164|  4.30k|      }
  165|  4.30k|   }
_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|  4.30k|      {
   73|  4.30k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.30k|         else {
   84|  4.30k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.30k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.30k|      }
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|  4.30k|      {
   59|  4.30k|         return Rule::match( in );
   60|  4.30k|      }
_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|  6.93k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.93k|      else {
  108|  6.93k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.93k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.93k|         constexpr bool has_apply_void = enable_action && internal::has_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.93k|         constexpr bool has_apply_bool = enable_action && internal::has_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.93k|         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.93k|         constexpr bool has_apply0_void = enable_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.93k|         constexpr bool has_apply0_bool = enable_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.93k|         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.93k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.93k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.93k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.93k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.93k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.93k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.93k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  6.93k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.93k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.93k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.93k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.93k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 6.93k, 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.93k|            else if constexpr( has_apply0_bool ) {
  153|  6.93k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  6.93k|            }
  155|  6.93k|         }
  156|  6.93k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 6.93k, False: 0]
  ------------------
  157|  6.93k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  6.93k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  6.93k|         (void)m( result );
  163|  6.93k|         return result;
  164|  6.93k|      }
  165|  6.93k|   }
_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|  6.93k|      {
   73|  6.93k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.93k|         else {
   84|  6.93k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.93k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.93k|      }
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|  6.93k|      {
   44|  6.93k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.93k|      }
_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|  3.50k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.50k|      else {
  108|  3.50k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.50k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.50k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.50k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.50k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.50k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.50k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.50k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.50k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.50k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.50k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.50k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.50k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.50k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.50k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.50k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.42k, False: 81]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.42k|            else if constexpr( has_apply0_bool ) {
  153|  3.42k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.42k|            }
  155|  3.42k|         }
  156|  3.50k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.42k, False: 81]
  ------------------
  157|  3.42k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.42k|         }
  159|     81|         else {
  160|     81|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     81|         }
  162|  3.50k|         (void)m( result );
  163|  3.50k|         return result;
  164|  3.50k|      }
  165|  3.50k|   }
_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|  3.50k|      {
   73|  3.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|  3.50k|         else {
   84|  3.50k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.50k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.50k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_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|  3.50k|      {
   44|  3.50k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.50k|      }
_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|  3.44k|   {
  104|  3.44k|      if constexpr( !Control< Rule >::enable ) {
  105|  3.44k|         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.44k|   }
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|  3.44k|      {
   44|  3.44k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  3.44k|      }
_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|  8.54k|   {
  104|  8.54k|      if constexpr( !Control< Rule >::enable ) {
  105|  8.54k|         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.54k|   }
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|  8.54k|      {
   44|  8.54k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.54k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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: 3.31k, False: 117]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.31k|            else if constexpr( has_apply0_bool ) {
  153|  3.31k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.31k|            }
  155|  3.31k|         }
  156|  3.42k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.31k, False: 117]
  ------------------
  157|  3.31k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.31k|         }
  159|    117|         else {
  160|    117|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    117|         }
  162|  3.42k|         (void)m( result );
  163|  3.42k|         return result;
  164|  3.42k|      }
  165|  3.42k|   }
_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|  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_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|  3.42k|      {
   59|  3.42k|         return Rule::match( in );
   60|  3.42k|      }
_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|  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): [True: 0, Folded]
  ------------------
  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): [True: 10.0k, Folded]
  |  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): [True: 10.0k, Folded]
  |  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: 9.01k, False: 1.01k]
  ------------------
  143|  9.01k|            if constexpr( has_apply_void ) {
  144|  9.01k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  9.01k|         }
  156|  10.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.97k, False: 1.06k]
  ------------------
  157|  8.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.97k|         }
  159|  1.06k|         else {
  160|  1.06k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.06k|         }
  162|  10.0k|         (void)m( result );
  163|  10.0k|         return result;
  164|  10.0k|      }
  165|  10.0k|   }
_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|  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_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|  10.0k|      {
   44|  10.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  10.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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: 9.26k, False: 772]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.26k|            else if constexpr( has_apply0_bool ) {
  153|  9.26k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.26k|            }
  155|  9.26k|         }
  156|  10.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.26k, False: 772]
  ------------------
  157|  9.26k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.26k|         }
  159|    772|         else {
  160|    772|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    772|         }
  162|  10.0k|         (void)m( result );
  163|  10.0k|         return result;
  164|  10.0k|      }
  165|  10.0k|   }
_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|  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_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|  10.0k|      {
   59|  10.0k|         return Rule::match( in );
   60|  10.0k|      }
_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|  9.26k|   {
  104|  9.26k|      if constexpr( !Control< Rule >::enable ) {
  105|  9.26k|         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|  9.26k|   }
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|  9.26k|      {
   44|  9.26k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.26k|      }
_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|  9.26k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.26k|      else {
  108|  9.26k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.26k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.26k|         constexpr bool has_apply_void = enable_action && internal::has_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.26k|         constexpr bool has_apply_bool = enable_action && internal::has_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.26k|         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.26k|         constexpr bool has_apply0_void = enable_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.26k|         constexpr bool has_apply0_bool = enable_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.26k|         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.26k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.26k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.26k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.26k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.26k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.26k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.26k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.26k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.26k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.26k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.26k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.26k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.01k, 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|  9.01k|            else if constexpr( has_apply0_bool ) {
  153|  9.01k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.01k|            }
  155|  9.01k|         }
  156|  9.26k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.01k, False: 245]
  ------------------
  157|  9.01k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.01k|         }
  159|    245|         else {
  160|    245|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    245|         }
  162|  9.26k|         (void)m( result );
  163|  9.26k|         return result;
  164|  9.26k|      }
  165|  9.26k|   }
_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|  9.26k|      {
   73|  9.26k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.26k|         else {
   84|  9.26k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.26k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.26k|      }
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|  9.26k|      {
   44|  9.26k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.26k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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.01k, False: 9.70M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.01k|            else if constexpr( has_apply0_bool ) {
  153|  9.01k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.01k|            }
  155|  9.01k|         }
  156|  9.71M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.01k, False: 9.70M]
  ------------------
  157|  9.01k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.01k|         }
  159|  9.70M|         else {
  160|  9.70M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.70M|         }
  162|  9.71M|         (void)m( result );
  163|  9.71M|         return result;
  164|  9.71M|      }
  165|  9.71M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  9.71M|      {
   73|  9.71M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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_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|  9.71M|      {
   59|  9.71M|         return Rule::match( in );
   60|  9.71M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.70M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.70M|      else {
  108|  9.70M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.70M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.70M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.70M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.70M|         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.70M|         constexpr bool has_apply0_void = enable_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.70M|         constexpr bool has_apply0_bool = enable_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.70M|         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.70M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.70M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.70M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.70M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.70M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.70M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.70M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.70M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.70M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.70M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.70M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.70M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.70M, False: 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|  9.70M|            else if constexpr( has_apply0_bool ) {
  153|  9.70M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.70M|            }
  155|  9.70M|         }
  156|  9.70M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.70M, False: 245]
  ------------------
  157|  9.70M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.70M|         }
  159|    245|         else {
  160|    245|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    245|         }
  162|  9.70M|         (void)m( result );
  163|  9.70M|         return result;
  164|  9.70M|      }
  165|  9.70M|   }
_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|  9.70M|      {
   73|  9.70M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.70M|         else {
   84|  9.70M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.70M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.70M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_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|  9.70M|      {
   44|  9.70M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.70M|      }
_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|  9.70M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.70M|      else {
  108|  9.70M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.70M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.70M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.70M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.70M|         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.70M|         constexpr bool has_apply0_void = enable_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.70M|         constexpr bool has_apply0_bool = enable_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.70M|         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.70M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.70M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.70M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.70M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.70M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.70M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.70M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.70M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.70M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.70M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.70M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.70M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 99.2k, False: 9.60M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  99.2k|            else if constexpr( has_apply0_bool ) {
  153|  99.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  99.2k|            }
  155|  99.2k|         }
  156|  9.70M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 99.2k, False: 9.60M]
  ------------------
  157|  99.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  99.2k|         }
  159|  9.60M|         else {
  160|  9.60M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.60M|         }
  162|  9.70M|         (void)m( result );
  163|  9.70M|         return result;
  164|  9.70M|      }
  165|  9.70M|   }
_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|  9.70M|      {
   73|  9.70M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.70M|         else {
   84|  9.70M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.70M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.70M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_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|  9.70M|      {
   44|  9.70M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.70M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.70M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.70M|      else {
  108|  9.70M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.70M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.70M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.70M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.70M|         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.70M|         constexpr bool has_apply0_void = enable_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.70M|         constexpr bool has_apply0_bool = enable_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.70M|         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.70M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.70M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.70M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.70M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.70M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.70M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.70M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.70M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.70M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.70M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.70M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.70M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 99.3k, False: 9.60M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  99.3k|            else if constexpr( has_apply0_bool ) {
  153|  99.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  99.3k|            }
  155|  99.3k|         }
  156|  9.70M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 99.3k, False: 9.60M]
  ------------------
  157|  99.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  99.3k|         }
  159|  9.60M|         else {
  160|  9.60M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.60M|         }
  162|  9.70M|         (void)m( result );
  163|  9.70M|         return result;
  164|  9.70M|      }
  165|  9.70M|   }
_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|  9.70M|      {
   73|  9.70M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.70M|         else {
   84|  9.70M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.70M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.70M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  9.70M|      {
   59|  9.70M|         return Rule::match( in );
   60|  9.70M|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSN_11char_traitsIcEENSN_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  99.3k|   {
  104|  99.3k|      if constexpr( !Control< Rule >::enable ) {
  105|  99.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|  99.3k|   }
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|  99.3k|      {
   44|  99.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  99.3k|      }
_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|  99.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  99.3k|      else {
  108|  99.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  99.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  99.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|  99.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|  99.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|  99.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|  99.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|  99.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|  99.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  99.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  99.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  99.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|  99.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  99.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  99.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|  99.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  99.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  99.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  99.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  99.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 99.2k, False: 68]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  99.2k|            else if constexpr( has_apply0_bool ) {
  153|  99.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  99.2k|            }
  155|  99.2k|         }
  156|  99.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 99.2k, False: 68]
  ------------------
  157|  99.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  99.2k|         }
  159|     68|         else {
  160|     68|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     68|         }
  162|  99.3k|         (void)m( result );
  163|  99.3k|         return result;
  164|  99.3k|      }
  165|  99.3k|   }
_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|  99.3k|      {
   73|  99.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|  99.3k|         else {
   84|  99.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  99.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  99.3k|      }
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|  99.3k|      {
   44|  99.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  99.3k|      }
_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|  99.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  99.3k|      else {
  108|  99.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  99.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  99.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|  99.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|  99.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|  99.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|  99.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|  99.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|  99.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  99.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  99.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  99.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|  99.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  99.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  99.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|  99.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  99.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  99.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  99.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  99.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 25.8k, False: 73.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|  25.8k|            else if constexpr( has_apply0_bool ) {
  153|  25.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  25.8k|            }
  155|  25.8k|         }
  156|  99.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 25.8k, False: 73.4k]
  ------------------
  157|  25.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  25.8k|         }
  159|  73.4k|         else {
  160|  73.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  73.4k|         }
  162|  99.3k|         (void)m( result );
  163|  99.3k|         return result;
  164|  99.3k|      }
  165|  99.3k|   }
_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|  99.3k|      {
   73|  99.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|  99.3k|         else {
   84|  99.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  99.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  99.3k|      }
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|  99.3k|      {
   44|  99.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  99.3k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  99.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  99.3k|      else {
  108|  99.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  99.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  99.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|  99.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|  99.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|  99.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|  99.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|  99.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|  99.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  99.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  99.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  99.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|  99.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  99.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  99.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|  99.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  99.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  99.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  99.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  99.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 25.8k, False: 73.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|  25.8k|            else if constexpr( has_apply0_bool ) {
  153|  25.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  25.8k|            }
  155|  25.8k|         }
  156|  99.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 25.8k, False: 73.4k]
  ------------------
  157|  25.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  25.8k|         }
  159|  73.4k|         else {
  160|  73.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  73.4k|         }
  162|  99.3k|         (void)m( result );
  163|  99.3k|         return result;
  164|  99.3k|      }
  165|  99.3k|   }
_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|  99.3k|      {
   73|  99.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|  99.3k|         else {
   84|  99.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  99.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  99.3k|      }
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|  99.3k|      {
   59|  99.3k|         return Rule::match( in );
   60|  99.3k|      }
_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|  25.8k|   {
  104|  25.8k|      if constexpr( !Control< Rule >::enable ) {
  105|  25.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|  25.8k|   }
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|  25.8k|      {
   44|  25.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  25.8k|      }
_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|  25.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  25.8k|      else {
  108|  25.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  25.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  25.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|  25.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|  25.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|  25.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|  25.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|  25.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|  25.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  25.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  25.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  25.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|  25.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  25.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  25.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|  25.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  25.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  25.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  25.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  25.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 25.8k, False: 33]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.8k|            else if constexpr( has_apply0_bool ) {
  153|  25.8k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  25.8k|            }
  155|  25.8k|         }
  156|  25.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 25.8k, False: 33]
  ------------------
  157|  25.8k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  25.8k|         }
  159|     33|         else {
  160|     33|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     33|         }
  162|  25.8k|         (void)m( result );
  163|  25.8k|         return result;
  164|  25.8k|      }
  165|  25.8k|   }
_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|  25.8k|      {
   73|  25.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|  25.8k|         else {
   84|  25.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  25.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  25.8k|      }
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|  25.8k|      {
   44|  25.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  25.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  51.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  51.7k|      else {
  108|  51.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  51.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  51.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|  51.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|  51.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|  51.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|  51.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|  51.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|  51.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  51.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  51.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  51.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|  51.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  51.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  51.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|  51.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  51.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  51.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  51.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  51.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 51.7k, False: 33]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  51.7k|            else if constexpr( has_apply0_bool ) {
  153|  51.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  51.7k|            }
  155|  51.7k|         }
  156|  51.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 51.7k, False: 33]
  ------------------
  157|  51.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  51.7k|         }
  159|     33|         else {
  160|     33|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     33|         }
  162|  51.7k|         (void)m( result );
  163|  51.7k|         return result;
  164|  51.7k|      }
  165|  51.7k|   }
_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|  51.7k|      {
   73|  51.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|  51.7k|         else {
   84|  51.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  51.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  51.7k|      }
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|  51.7k|      {
   59|  51.7k|         return Rule::match( in );
   60|  51.7k|      }
_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|  73.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  73.4k|      else {
  108|  73.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  73.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  73.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|  73.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|  73.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|  73.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|  73.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|  73.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|  73.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  73.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  73.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  73.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|  73.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  73.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  73.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|  73.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  73.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  73.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  73.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  73.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.4k, False: 42.9k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  73.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.4k, False: 42.9k]
  ------------------
  157|  30.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.4k|         }
  159|  42.9k|         else {
  160|  42.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  42.9k|         }
  162|  73.4k|         (void)m( result );
  163|  73.4k|         return result;
  164|  73.4k|      }
  165|  73.4k|   }
_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|  73.4k|      {
   73|  73.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|  73.4k|         else {
   84|  73.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  73.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  73.4k|      }
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|  73.4k|      {
   44|  73.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  73.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   108k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   108k|      else {
  108|   108k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   108k|         using iterator_t = typename ParseInput::iterator_t;
  111|   108k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   108k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   108k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   108k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   108k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   108k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   108k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   108k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   108k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   108k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   108k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   108k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   108k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   108k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   108k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   108k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   108k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   108k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 36.1k, False: 71.9k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  36.1k|            else if constexpr( has_apply0_bool ) {
  153|  36.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  36.1k|            }
  155|  36.1k|         }
  156|   108k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 36.1k, False: 71.9k]
  ------------------
  157|  36.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  36.1k|         }
  159|  71.9k|         else {
  160|  71.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  71.9k|         }
  162|   108k|         (void)m( result );
  163|   108k|         return result;
  164|   108k|      }
  165|   108k|   }
_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|   108k|      {
   73|   108k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   108k|         else {
   84|   108k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   108k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   108k|      }
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|   108k|      {
   59|   108k|         return Rule::match( in );
   60|   108k|      }
_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|  30.4k|   {
  104|  30.4k|      if constexpr( !Control< Rule >::enable ) {
  105|  30.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|  30.4k|   }
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|  30.4k|      {
   44|  30.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.4k|      }
_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|  30.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  30.4k|      else {
  108|  30.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  30.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  30.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|  30.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|  30.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|  30.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|  30.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|  30.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|  30.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  30.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  30.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  30.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|  30.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  30.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  30.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|  30.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  30.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  30.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  30.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  30.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.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|  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|  30.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.4k, False: 0]
  ------------------
  157|  30.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.4k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  30.4k|         (void)m( result );
  163|  30.4k|         return result;
  164|  30.4k|      }
  165|  30.4k|   }
_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|  30.4k|      {
   73|  30.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|  30.4k|         else {
   84|  30.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  30.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  30.4k|      }
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|  30.4k|      {
   44|  30.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  30.4k|      }
_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|  42.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.9k|      else {
  108|  42.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.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|  42.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|  42.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|  42.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|  42.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|  42.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|  42.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.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|  42.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.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|  42.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 41.5k, 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|  41.5k|            else if constexpr( has_apply0_bool ) {
  153|  41.5k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  41.5k|            }
  155|  41.5k|         }
  156|  42.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 41.5k, False: 1.36k]
  ------------------
  157|  41.5k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  41.5k|         }
  159|  1.36k|         else {
  160|  1.36k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.36k|         }
  162|  42.9k|         (void)m( result );
  163|  42.9k|         return result;
  164|  42.9k|      }
  165|  42.9k|   }
_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|  42.9k|      {
   73|  42.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|  42.9k|         else {
   84|  42.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.9k|      }
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|  42.9k|      {
   59|  42.9k|         return Rule::match( in );
   60|  42.9k|      }
_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.36k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.36k|      else {
  108|  1.36k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.36k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.36k|         constexpr bool has_apply_void = enable_action && internal::has_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.36k|         constexpr bool has_apply_bool = enable_action && internal::has_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.36k|         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.36k|         constexpr bool has_apply0_void = enable_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.36k|         constexpr bool has_apply0_bool = enable_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.36k|         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.36k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.36k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.36k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.36k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.36k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.36k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.36k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  1.36k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.36k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.36k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.36k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.36k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.32k, 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|  1.32k|            else if constexpr( has_apply0_bool ) {
  153|  1.32k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.32k|            }
  155|  1.32k|         }
  156|  1.36k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.32k, False: 35]
  ------------------
  157|  1.32k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.32k|         }
  159|     35|         else {
  160|     35|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     35|         }
  162|  1.36k|         (void)m( result );
  163|  1.36k|         return result;
  164|  1.36k|      }
  165|  1.36k|   }
_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.36k|      {
   73|  1.36k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.36k|         else {
   84|  1.36k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.36k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.36k|      }
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.36k|      {
   59|  1.36k|         return Rule::match( in );
   60|  1.36k|      }
_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|  9.60M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.60M|      else {
  108|  9.60M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.60M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.60M|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  9.60M|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  9.60M|         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.60M|         constexpr bool has_apply0_void = enable_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.60M|         constexpr bool has_apply0_bool = enable_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.60M|         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.60M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.60M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.60M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.60M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.60M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.60M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.60M|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  9.60M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.60M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.60M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.60M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.60M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.60M, False: 177]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.60M|            else if constexpr( has_apply0_bool ) {
  153|  9.60M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.60M|            }
  155|  9.60M|         }
  156|  9.60M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.60M, False: 177]
  ------------------
  157|  9.60M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.60M|         }
  159|    177|         else {
  160|    177|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    177|         }
  162|  9.60M|         (void)m( result );
  163|  9.60M|         return result;
  164|  9.60M|      }
  165|  9.60M|   }
_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|  9.60M|      {
   73|  9.60M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.60M|         else {
   84|  9.60M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.60M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.60M|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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|  9.60M|      {
   59|  9.60M|         return Rule::match( in );
   60|  9.60M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser19condition_attributeELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  20.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  20.6k|      else {
  108|  20.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  20.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  20.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|  20.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|  20.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|  20.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|  20.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|  20.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|  20.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  20.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  20.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  20.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|  20.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  20.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  20.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|  20.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  20.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  20.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  20.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  20.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.45k, False: 16.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.45k|            else if constexpr( has_apply0_bool ) {
  153|  4.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.45k|            }
  155|  4.45k|         }
  156|  20.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.45k, False: 16.1k]
  ------------------
  157|  4.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.45k|         }
  159|  16.1k|         else {
  160|  16.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.1k|         }
  162|  20.6k|         (void)m( result );
  163|  20.6k|         return result;
  164|  20.6k|      }
  165|  20.6k|   }
_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|  20.6k|      {
   73|  20.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|  20.6k|         else {
   84|  20.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  20.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  20.6k|      }
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|  20.6k|      {
   44|  20.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  20.6k|      }
_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|  20.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  20.6k|      else {
  108|  20.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  20.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  20.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|  20.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|  20.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|  20.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|  20.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|  20.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|  20.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  20.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  20.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  20.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|  20.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  20.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  20.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|  20.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  20.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  20.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  20.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  20.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.45k, False: 16.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.45k|            else if constexpr( has_apply0_bool ) {
  153|  4.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.45k|            }
  155|  4.45k|         }
  156|  20.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.45k, False: 16.1k]
  ------------------
  157|  4.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.45k|         }
  159|  16.1k|         else {
  160|  16.1k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  16.1k|         }
  162|  20.6k|         (void)m( result );
  163|  20.6k|         return result;
  164|  20.6k|      }
  165|  20.6k|   }
_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|  20.6k|      {
   73|  20.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|  20.6k|         else {
   84|  20.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  20.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  20.6k|      }
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|  20.6k|      {
   44|  20.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  20.6k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser6str_ifELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  20.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  20.6k|      else {
  108|  20.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  20.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  20.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): [True: 0, Folded]
  ------------------
  112|  20.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|  20.6k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 20.6k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  20.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|  20.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|  20.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|  20.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  20.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  20.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  20.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|  20.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  20.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  20.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|  20.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 20.6k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  20.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  20.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  20.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  20.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.35k, False: 13.2k]
  ------------------
  143|  7.35k|            if constexpr( has_apply_void ) {
  144|  7.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|  7.35k|         }
  156|  20.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.34k, False: 13.2k]
  ------------------
  157|  7.34k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.34k|         }
  159|  13.2k|         else {
  160|  13.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  13.2k|         }
  162|  20.6k|         (void)m( result );
  163|  20.6k|         return result;
  164|  20.6k|      }
  165|  20.6k|   }
_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|  20.6k|      {
   73|  20.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|  20.6k|         else {
   84|  20.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  20.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  20.6k|      }
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|  20.6k|      {
   59|  20.6k|         return Rule::match( in );
   60|  20.6k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_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: 636k, 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|   636k|            else if constexpr( has_apply0_bool ) {
  153|   636k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   636k|            }
  155|   636k|         }
  156|   640k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 636k, False: 3.40k]
  ------------------
  157|   636k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   636k|         }
  159|  3.40k|         else {
  160|  3.40k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.40k|         }
  162|   640k|         (void)m( result );
  163|   640k|         return result;
  164|   640k|      }
  165|   640k|   }
_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|   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_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|   640k|      {
   44|   640k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   640k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_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: 636k, 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|   636k|            else if constexpr( has_apply0_bool ) {
  153|   636k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   636k|            }
  155|   636k|         }
  156|   640k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 636k, False: 3.40k]
  ------------------
  157|   636k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   636k|         }
  159|  3.40k|         else {
  160|  3.40k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.40k|         }
  162|   640k|         (void)m( result );
  163|   640k|         return result;
  164|   640k|      }
  165|   640k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   640k|      {
   59|   640k|         return Rule::match( in );
   60|   640k|      }
_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: 34.2k, False: 645k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.2k|            else if constexpr( has_apply0_bool ) {
  153|  34.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  34.2k|            }
  155|  34.2k|         }
  156|   679k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 34.2k, False: 645k]
  ------------------
  157|  34.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  34.2k|         }
  159|   645k|         else {
  160|   645k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   645k|         }
  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|  7.32k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.32k|      else {
  108|  7.32k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.32k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.32k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.32k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.32k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.32k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.32k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.32k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.32k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.32k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.32k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.32k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.45k, False: 2.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|  4.45k|            else if constexpr( has_apply0_bool ) {
  153|  4.45k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.45k|            }
  155|  4.45k|         }
  156|  7.32k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.45k, False: 2.87k]
  ------------------
  157|  4.45k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.45k|         }
  159|  2.87k|         else {
  160|  2.87k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.87k|         }
  162|  7.32k|         (void)m( result );
  163|  7.32k|         return result;
  164|  7.32k|      }
  165|  7.32k|   }
_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|  7.32k|      {
   73|  7.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|  7.32k|         else {
   84|  7.32k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.32k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.32k|      }
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|  7.32k|      {
   44|  7.32k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.32k|      }
_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|  7.32k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.32k|      else {
  108|  7.32k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.32k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.32k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.32k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.32k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.32k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.32k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.32k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.32k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.32k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.32k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.32k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.15k, False: 4.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|  3.15k|            else if constexpr( has_apply0_bool ) {
  153|  3.15k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.15k|            }
  155|  3.15k|         }
  156|  7.32k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.15k, False: 4.16k]
  ------------------
  157|  3.15k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.15k|         }
  159|  4.16k|         else {
  160|  4.16k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.16k|         }
  162|  7.32k|         (void)m( result );
  163|  7.32k|         return result;
  164|  7.32k|      }
  165|  7.32k|   }
_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|  7.32k|      {
   73|  7.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|  7.32k|         else {
   84|  7.32k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.32k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.32k|      }
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|  7.32k|      {
   44|  7.32k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.32k|      }
_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|  7.32k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.32k|      else {
  108|  7.32k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.32k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.32k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.32k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.32k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.32k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.32k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.32k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.32k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.32k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.32k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.32k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 7.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|  7.32k|            else if constexpr( has_apply0_bool ) {
  153|  7.32k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  7.32k|            }
  155|  7.32k|         }
  156|  7.32k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 7.32k, False: 0]
  ------------------
  157|  7.32k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  7.32k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  7.32k|         (void)m( result );
  163|  7.32k|         return result;
  164|  7.32k|      }
  165|  7.32k|   }
_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|  7.32k|      {
   73|  7.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|  7.32k|         else {
   84|  7.32k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.32k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.32k|      }
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|  7.32k|      {
   44|  7.32k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.32k|      }
_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|  7.32k|   {
  104|  7.32k|      if constexpr( !Control< Rule >::enable ) {
  105|  7.32k|         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.32k|   }
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|  7.32k|      {
   44|  7.32k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.32k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.32k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.32k|      else {
  108|  7.32k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.32k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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): [True: 0, Folded]
  ------------------
  112|  7.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|  7.32k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 7.32k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  7.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|  7.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|  7.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|  7.32k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.32k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.32k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.32k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.32k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.32k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 7.32k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.32k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.32k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.32k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.32k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.15k, False: 5.17k]
  ------------------
  143|  2.15k|            if constexpr( has_apply_void ) {
  144|  2.15k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.15k|         }
  156|  7.32k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.15k, False: 5.17k]
  ------------------
  157|  2.15k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.15k|         }
  159|  5.17k|         else {
  160|  5.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.17k|         }
  162|  7.32k|         (void)m( result );
  163|  7.32k|         return result;
  164|  7.32k|      }
  165|  7.32k|   }
_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|  7.32k|      {
   73|  7.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|  7.32k|         else {
   84|  7.32k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.32k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.32k|      }
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|  7.32k|      {
   44|  7.32k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  7.32k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_all_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.32k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.32k|      else {
  108|  7.32k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.32k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.32k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.32k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.32k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.32k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.32k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.32k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.32k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.32k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.32k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.32k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 196, False: 7.12k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  7.32k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 196, False: 7.12k]
  ------------------
  157|    196|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    196|         }
  159|  7.12k|         else {
  160|  7.12k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  7.12k|         }
  162|  7.32k|         (void)m( result );
  163|  7.32k|         return result;
  164|  7.32k|      }
  165|  7.32k|   }
_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|  7.32k|      {
   73|  7.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|  7.32k|         else {
   84|  7.32k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.32k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.32k|      }
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|  7.32k|      {
   59|  7.32k|         return Rule::match( in );
   60|  7.32k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_one_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  7.12k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.12k|      else {
  108|  7.12k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.12k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.12k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.12k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.12k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.12k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.12k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.12k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.12k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.12k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.12k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.12k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 213, False: 6.91k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    213|            else if constexpr( has_apply0_bool ) {
  153|    213|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    213|            }
  155|    213|         }
  156|  7.12k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 213, False: 6.91k]
  ------------------
  157|    213|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    213|         }
  159|  6.91k|         else {
  160|  6.91k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.91k|         }
  162|  7.12k|         (void)m( result );
  163|  7.12k|         return result;
  164|  7.12k|      }
  165|  7.12k|   }
_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|  7.12k|      {
   73|  7.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|  7.12k|         else {
   84|  7.12k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.12k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.12k|      }
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|  7.12k|      {
   59|  7.12k|         return Rule::match( in );
   60|  7.12k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser11str_none_ofELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.91k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.91k|      else {
  108|  6.91k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.91k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.91k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.91k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.91k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.91k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.91k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.91k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.91k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.91k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.91k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.91k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 224, False: 6.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|    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|  6.91k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 224, False: 6.69k]
  ------------------
  157|    224|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    224|         }
  159|  6.69k|         else {
  160|  6.69k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  6.69k|         }
  162|  6.91k|         (void)m( result );
  163|  6.91k|         return result;
  164|  6.91k|      }
  165|  6.91k|   }
_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|  6.91k|      {
   73|  6.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|  6.91k|         else {
   84|  6.91k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.91k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.91k|      }
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|  6.91k|      {
   59|  6.91k|         return Rule::match( in );
   60|  6.91k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18str_equals_orderedELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.69k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.69k|      else {
  108|  6.69k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.69k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.69k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.69k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.69k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.69k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.69k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.69k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.69k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.69k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.69k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.69k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.06k, False: 5.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|  1.06k|            else if constexpr( has_apply0_bool ) {
  153|  1.06k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.06k|            }
  155|  1.06k|         }
  156|  6.69k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.06k, False: 5.62k]
  ------------------
  157|  1.06k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.06k|         }
  159|  5.62k|         else {
  160|  5.62k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.62k|         }
  162|  6.69k|         (void)m( result );
  163|  6.69k|         return result;
  164|  6.69k|      }
  165|  6.69k|   }
_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|  6.69k|      {
   73|  6.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|  6.69k|         else {
   84|  6.69k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.69k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.69k|      }
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|  6.69k|      {
   59|  6.69k|         return Rule::match( in );
   60|  6.69k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.62k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.62k|      else {
  108|  5.62k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.62k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.62k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.62k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.62k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.62k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.62k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.62k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.62k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.62k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.62k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.62k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 237, False: 5.38k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    237|            else if constexpr( has_apply0_bool ) {
  153|    237|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    237|            }
  155|    237|         }
  156|  5.62k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 237, False: 5.38k]
  ------------------
  157|    237|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    237|         }
  159|  5.38k|         else {
  160|  5.38k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.38k|         }
  162|  5.62k|         (void)m( result );
  163|  5.62k|         return result;
  164|  5.62k|      }
  165|  5.62k|   }
_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.62k|      {
   73|  5.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|  5.62k|         else {
   84|  5.62k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.62k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.62k|      }
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.62k|      {
   59|  5.62k|         return Rule::match( in );
   60|  5.62k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser13str_match_allELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  5.38k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.38k|      else {
  108|  5.38k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.38k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.38k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.38k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.38k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.38k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.38k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.38k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.38k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.38k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.38k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.38k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 212, False: 5.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|    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|  5.38k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 212, False: 5.17k]
  ------------------
  157|    212|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    212|         }
  159|  5.17k|         else {
  160|  5.17k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  5.17k|         }
  162|  5.38k|         (void)m( result );
  163|  5.38k|         return result;
  164|  5.38k|      }
  165|  5.38k|   }
_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|  5.38k|      {
   73|  5.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|  5.38k|         else {
   84|  5.38k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.38k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.38k|      }
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|  5.38k|      {
   59|  5.38k|         return Rule::match( in );
   60|  5.38k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  7.32k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  7.32k|      else {
  108|  7.32k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  7.32k|         using iterator_t = typename ParseInput::iterator_t;
  111|  7.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|  7.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|  7.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|  7.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|  7.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|  7.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|  7.32k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  7.32k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  7.32k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  7.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|  7.32k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  7.32k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  7.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|  7.32k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  7.32k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  7.32k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  7.32k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  7.32k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.97k, False: 2.35k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.97k|            else if constexpr( has_apply0_bool ) {
  153|  4.97k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.97k|            }
  155|  4.97k|         }
  156|  7.32k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.97k, False: 2.35k]
  ------------------
  157|  4.97k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.97k|         }
  159|  2.35k|         else {
  160|  2.35k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.35k|         }
  162|  7.32k|         (void)m( result );
  163|  7.32k|         return result;
  164|  7.32k|      }
  165|  7.32k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  7.32k|      {
   73|  7.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|  7.32k|         else {
   84|  7.32k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  7.32k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  7.32k|      }
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|  7.32k|      {
   59|  7.32k|         return Rule::match( in );
   60|  7.32k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  8.71k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  8.71k|      else {
  108|  8.71k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  8.71k|         using iterator_t = typename ParseInput::iterator_t;
  111|  8.71k|         constexpr bool has_apply_void = enable_action && internal::has_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.71k|         constexpr bool has_apply_bool = enable_action && internal::has_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.71k|         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.71k|         constexpr bool has_apply0_void = enable_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.71k|         constexpr bool has_apply0_bool = enable_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.71k|         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.71k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  8.71k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  8.71k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  8.71k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.71k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  8.71k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  8.71k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  8.71k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  8.71k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  8.71k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  8.71k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  8.71k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.71k, 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|  8.71k|            else if constexpr( has_apply0_bool ) {
  153|  8.71k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.71k|            }
  155|  8.71k|         }
  156|  8.71k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.71k, False: 0]
  ------------------
  157|  8.71k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.71k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  8.71k|         (void)m( result );
  163|  8.71k|         return result;
  164|  8.71k|      }
  165|  8.71k|   }
_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|  8.71k|      {
   73|  8.71k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.71k|         else {
   84|  8.71k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  8.71k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  8.71k|      }
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|  8.71k|      {
   44|  8.71k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  8.71k|      }
_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|  4.97k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.97k|      else {
  108|  4.97k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.97k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.97k|         constexpr bool has_apply_void = enable_action && internal::has_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.97k|         constexpr bool has_apply_bool = enable_action && internal::has_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.97k|         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.97k|         constexpr bool has_apply0_void = enable_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.97k|         constexpr bool has_apply0_bool = enable_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.97k|         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.97k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.97k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.97k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.97k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.97k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.97k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.97k|         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.97k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.97k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.97k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.97k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.97k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.73k, 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|  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|  4.97k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.73k, False: 1.23k]
  ------------------
  157|  3.73k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.73k|         }
  159|  1.23k|         else {
  160|  1.23k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.23k|         }
  162|  4.97k|         (void)m( result );
  163|  4.97k|         return result;
  164|  4.97k|      }
  165|  4.97k|   }
_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|  4.97k|      {
   73|  4.97k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.97k|         else {
   84|  4.97k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.97k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.97k|      }
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|  4.97k|      {
   44|  4.97k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.97k|      }
_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|  4.84k|   {
  104|  4.84k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.84k|         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.84k|   }
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|  4.84k|      {
   44|  4.84k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.84k|      }
_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|   630k|   {
  104|   630k|      if constexpr( !Control< Rule >::enable ) {
  105|   630k|         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|   630k|   }
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|   630k|      {
   44|   630k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   630k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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: 3.15k, False: 581]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.15k|            else if constexpr( has_apply0_bool ) {
  153|  3.15k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.15k|            }
  155|  3.15k|         }
  156|  3.73k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.15k, False: 581]
  ------------------
  157|  3.15k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.15k|         }
  159|    581|         else {
  160|    581|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    581|         }
  162|  3.73k|         (void)m( result );
  163|  3.73k|         return result;
  164|  3.73k|      }
  165|  3.73k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_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_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|  3.73k|      {
   59|  3.73k|         return Rule::match( in );
   60|  3.73k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   635k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   635k|      else {
  108|   635k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   635k|         using iterator_t = typename ParseInput::iterator_t;
  111|   635k|         constexpr bool has_apply_void = 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|   635k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   635k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 635k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   635k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   635k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   635k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   635k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   635k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   635k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   635k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   635k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   635k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   635k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   635k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 635k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   635k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   635k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   635k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   635k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 633k, False: 1.54k]
  ------------------
  143|   633k|            if constexpr( has_apply_void ) {
  144|   633k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   633k|         }
  156|   635k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 631k, False: 3.33k]
  ------------------
  157|   631k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   631k|         }
  159|  3.33k|         else {
  160|  3.33k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.33k|         }
  162|   635k|         (void)m( result );
  163|   635k|         return result;
  164|   635k|      }
  165|   635k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9conditionELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   635k|      {
   73|   635k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   635k|         else {
   84|   635k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   635k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   635k|      }
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|   635k|      {
   44|   635k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   635k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser8negationEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   635k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   635k|      else {
  108|   635k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   635k|         using iterator_t = typename ParseInput::iterator_t;
  111|   635k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   635k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   635k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   635k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   635k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   635k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   635k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   635k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   635k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   635k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   635k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   635k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   635k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   635k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   635k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   635k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   635k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   635k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 635k, 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|   635k|            else if constexpr( has_apply0_bool ) {
  153|   635k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   635k|            }
  155|   635k|         }
  156|   635k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 635k, False: 0]
  ------------------
  157|   635k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   635k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   635k|         (void)m( result );
  163|   635k|         return result;
  164|   635k|      }
  165|   635k|   }
_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|   635k|      {
   73|   635k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   635k|         else {
   84|   635k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   635k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   635k|      }
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|   635k|      {
   44|   635k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   635k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   635k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   635k|      else {
  108|   635k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   635k|         using iterator_t = typename ParseInput::iterator_t;
  111|   635k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   635k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   635k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   635k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   635k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   635k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   635k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   635k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   635k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   635k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   635k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   635k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   635k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   635k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   635k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   635k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   635k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   635k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 347, False: 634k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|   635k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 347, False: 634k]
  ------------------
  157|    347|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    347|         }
  159|   634k|         else {
  160|   634k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   634k|         }
  162|   635k|         (void)m( result );
  163|   635k|         return result;
  164|   635k|      }
  165|   635k|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser8negationELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|   635k|      {
   73|   635k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   635k|         else {
   84|   635k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   635k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   635k|      }
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|   635k|      {
   59|   635k|         return Rule::match( in );
   60|   635k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser20condition_identifierELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   635k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   635k|      else {
  108|   635k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   635k|         using iterator_t = typename ParseInput::iterator_t;
  111|   635k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   635k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   635k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   635k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   635k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   635k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   635k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   635k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   635k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   635k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   635k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   635k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   635k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   635k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   635k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   635k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   635k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   635k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 634k, False: 1.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|   634k|            else if constexpr( has_apply0_bool ) {
  153|   634k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   634k|            }
  155|   634k|         }
  156|   635k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 634k, False: 1.15k]
  ------------------
  157|   634k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   634k|         }
  159|  1.15k|         else {
  160|  1.15k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.15k|         }
  162|   635k|         (void)m( result );
  163|   635k|         return result;
  164|   635k|      }
  165|   635k|   }
_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|   635k|      {
   73|   635k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   635k|         else {
   84|   635k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   635k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   635k|      }
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|   635k|      {
   44|   635k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   635k|      }
_ZN3tao5pegtl5matchINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   635k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   635k|      else {
  108|   635k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   635k|         using iterator_t = typename ParseInput::iterator_t;
  111|   635k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   635k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   635k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   635k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   635k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   635k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   635k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   635k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   635k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   635k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   635k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   635k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   635k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   635k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   635k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   635k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   635k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   635k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 634k, False: 1.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|   634k|            else if constexpr( has_apply0_bool ) {
  153|   634k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   634k|            }
  155|   634k|         }
  156|   635k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 634k, False: 1.15k]
  ------------------
  157|   634k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   634k|         }
  159|  1.15k|         else {
  160|  1.15k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.15k|         }
  162|   635k|         (void)m( result );
  163|   635k|         return result;
  164|   635k|      }
  165|   635k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   635k|      {
   73|   635k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   635k|         else {
   84|   635k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   635k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   635k|      }
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|   635k|      {
   59|   635k|         return Rule::match( in );
   60|   635k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEDaRT4_DpOT5_:
  103|   634k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   634k|      else {
  108|   634k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   634k|         using iterator_t = typename ParseInput::iterator_t;
  111|   634k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   634k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   634k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   634k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   634k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   634k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   634k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   634k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   634k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   634k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   634k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   634k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   634k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   634k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   634k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   634k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   634k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   634k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 634k, 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|   634k|            else if constexpr( has_apply0_bool ) {
  153|   634k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   634k|            }
  155|   634k|         }
  156|   634k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 634k, False: 0]
  ------------------
  157|   634k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   634k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|   634k|         (void)m( result );
  163|   634k|         return result;
  164|   634k|      }
  165|   634k|   }
_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|   634k|      {
   73|   634k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   634k|         else {
   84|   634k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   634k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   634k|      }
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|   634k|      {
   44|   634k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   634k|      }
_ZN3tao5pegtl5matchINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  25.5M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  25.5M|      else {
  108|  25.5M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  25.5M|         using iterator_t = typename ParseInput::iterator_t;
  111|  25.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|  25.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|  25.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|  25.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|  25.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|  25.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|  25.5M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  25.5M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  25.5M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  25.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|  25.5M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  25.5M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  25.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|  25.5M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  25.5M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  25.5M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  25.5M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  25.5M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 24.9M, False: 634k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.9M|            else if constexpr( has_apply0_bool ) {
  153|  24.9M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  24.9M|            }
  155|  24.9M|         }
  156|  25.5M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 24.9M, False: 634k]
  ------------------
  157|  24.9M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  24.9M|         }
  159|   634k|         else {
  160|   634k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   634k|         }
  162|  25.5M|         (void)m( result );
  163|  25.5M|         return result;
  164|  25.5M|      }
  165|  25.5M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  25.5M|      {
   73|  25.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|  25.5M|         else {
   84|  25.5M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  25.5M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  25.5M|      }
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|  25.5M|      {
   59|  25.5M|         return Rule::match( in );
   60|  25.5M|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|   634k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   634k|      else {
  108|   634k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   634k|         using iterator_t = typename ParseInput::iterator_t;
  111|   634k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   634k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   634k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   634k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   634k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   634k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   634k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   634k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   634k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   634k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   634k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   634k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   634k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   634k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   634k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   634k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   634k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   634k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 633k, False: 388]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   633k|            else if constexpr( has_apply0_bool ) {
  153|   633k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   633k|            }
  155|   633k|         }
  156|   634k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 633k, False: 388]
  ------------------
  157|   633k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   633k|         }
  159|    388|         else {
  160|    388|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    388|         }
  162|   634k|         (void)m( result );
  163|   634k|         return result;
  164|   634k|      }
  165|   634k|   }
_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|   634k|      {
   73|   634k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   634k|         else {
   84|   634k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   634k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   634k|      }
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|   634k|      {
   44|   634k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   634k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser18condition_argumentELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   634k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   634k|      else {
  108|   634k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   634k|         using iterator_t = typename ParseInput::iterator_t;
  111|   634k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   634k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   634k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   634k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   634k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   634k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   634k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   634k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   634k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   634k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   634k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   634k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   634k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   634k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   634k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   634k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   634k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   634k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 48.3k, False: 585k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.3k|            else if constexpr( has_apply0_bool ) {
  153|  48.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  48.3k|            }
  155|  48.3k|         }
  156|   634k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 48.3k, False: 585k]
  ------------------
  157|  48.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  48.3k|         }
  159|   585k|         else {
  160|   585k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   585k|         }
  162|   634k|         (void)m( result );
  163|   634k|         return result;
  164|   634k|      }
  165|   634k|   }
_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|   634k|      {
   73|   634k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   634k|         else {
   84|   634k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   634k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   634k|      }
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|   634k|      {
   44|   634k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   634k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|   634k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   634k|      else {
  108|   634k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   634k|         using iterator_t = typename ParseInput::iterator_t;
  111|   634k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   634k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   634k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   634k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   634k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   634k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   634k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   634k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   634k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   634k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   634k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   634k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   634k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   634k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   634k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   634k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   634k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   634k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 48.7k, False: 585k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.7k|            else if constexpr( has_apply0_bool ) {
  153|  48.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  48.7k|            }
  155|  48.7k|         }
  156|   634k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 48.7k, False: 585k]
  ------------------
  157|  48.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  48.7k|         }
  159|   585k|         else {
  160|   585k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   585k|         }
  162|   634k|         (void)m( result );
  163|   634k|         return result;
  164|   634k|      }
  165|   634k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc40EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|   634k|      {
   73|   634k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   634k|         else {
   84|   634k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   634k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   634k|      }
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|   634k|      {
   59|   634k|         return Rule::match( in );
   60|   634k|      }
_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|  48.7k|   {
  104|  48.7k|      if constexpr( !Control< Rule >::enable ) {
  105|  48.7k|         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.7k|   }
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|  48.7k|      {
   44|  48.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  48.7k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  48.7k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  48.7k|      else {
  108|  48.7k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  48.7k|         using iterator_t = typename ParseInput::iterator_t;
  111|  48.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|  48.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|  48.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|  48.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|  48.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|  48.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|  48.7k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  48.7k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  48.7k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  48.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|  48.7k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  48.7k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  48.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|  48.7k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  48.7k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  48.7k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  48.7k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  48.7k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 48.3k, False: 388]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.3k|            else if constexpr( has_apply0_bool ) {
  153|  48.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  48.3k|            }
  155|  48.3k|         }
  156|  48.7k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 48.3k, False: 388]
  ------------------
  157|  48.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  48.3k|         }
  159|    388|         else {
  160|    388|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    388|         }
  162|  48.7k|         (void)m( result );
  163|  48.7k|         return result;
  164|  48.7k|      }
  165|  48.7k|   }
_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|  48.7k|      {
   73|  48.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|  48.7k|         else {
   84|  48.7k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  48.7k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  48.7k|      }
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|  48.7k|      {
   44|  48.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  48.7k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  50.7M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  50.7M|      else {
  108|  50.7M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  50.7M|         using iterator_t = typename ParseInput::iterator_t;
  111|  50.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|  50.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|  50.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|  50.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|  50.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|  50.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|  50.7M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  50.7M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  50.7M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  50.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|  50.7M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  50.7M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  50.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|  50.7M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  50.7M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  50.7M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  50.7M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  50.7M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 48.3k, False: 50.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|  48.3k|            else if constexpr( has_apply0_bool ) {
  153|  48.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  48.3k|            }
  155|  48.3k|         }
  156|  50.7M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 48.3k, False: 50.7M]
  ------------------
  157|  48.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  48.3k|         }
  159|  50.7M|         else {
  160|  50.7M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  50.7M|         }
  162|  50.7M|         (void)m( result );
  163|  50.7M|         return result;
  164|  50.7M|      }
  165|  50.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|  50.7M|      {
   73|  50.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|  50.7M|         else {
   84|  50.7M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  50.7M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  50.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|  50.7M|      {
   59|  50.7M|         return Rule::match( in );
   60|  50.7M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  50.7M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  50.7M|      else {
  108|  50.7M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  50.7M|         using iterator_t = typename ParseInput::iterator_t;
  111|  50.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|  50.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|  50.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|  50.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|  50.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|  50.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|  50.7M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  50.7M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  50.7M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  50.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|  50.7M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  50.7M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  50.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|  50.7M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  50.7M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  50.7M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  50.7M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  50.7M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 50.7M, False: 388]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  50.7M|            else if constexpr( has_apply0_bool ) {
  153|  50.7M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  50.7M|            }
  155|  50.7M|         }
  156|  50.7M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 50.7M, False: 388]
  ------------------
  157|  50.7M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  50.7M|         }
  159|    388|         else {
  160|    388|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    388|         }
  162|  50.7M|         (void)m( result );
  163|  50.7M|         return result;
  164|  50.7M|      }
  165|  50.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|  50.7M|      {
   73|  50.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|  50.7M|         else {
   84|  50.7M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  50.7M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  50.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|  50.7M|      {
   44|  50.7M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  50.7M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc41EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  50.7M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  50.7M|      else {
  108|  50.7M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  50.7M|         using iterator_t = typename ParseInput::iterator_t;
  111|  50.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|  50.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|  50.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|  50.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|  50.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|  50.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|  50.7M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  50.7M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  50.7M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  50.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|  50.7M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  50.7M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  50.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|  50.7M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  50.7M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  50.7M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  50.7M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  50.7M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 146k, False: 50.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|   146k|            else if constexpr( has_apply0_bool ) {
  153|   146k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   146k|            }
  155|   146k|         }
  156|  50.7M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 146k, False: 50.5M]
  ------------------
  157|   146k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   146k|         }
  159|  50.5M|         else {
  160|  50.5M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  50.5M|         }
  162|  50.7M|         (void)m( result );
  163|  50.7M|         return result;
  164|  50.7M|      }
  165|  50.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|  50.7M|      {
   73|  50.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|  50.7M|         else {
   84|  50.7M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  50.7M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  50.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|  50.7M|      {
   44|  50.7M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  50.7M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  50.7M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  50.7M|      else {
  108|  50.7M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  50.7M|         using iterator_t = typename ParseInput::iterator_t;
  111|  50.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|  50.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|  50.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|  50.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|  50.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|  50.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|  50.7M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  50.7M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  50.7M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  50.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|  50.7M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  50.7M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  50.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|  50.7M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  50.7M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  50.7M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  50.7M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  50.7M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 146k, False: 50.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|   146k|            else if constexpr( has_apply0_bool ) {
  153|   146k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   146k|            }
  155|   146k|         }
  156|  50.7M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 146k, False: 50.5M]
  ------------------
  157|   146k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   146k|         }
  159|  50.5M|         else {
  160|  50.5M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  50.5M|         }
  162|  50.7M|         (void)m( result );
  163|  50.7M|         return result;
  164|  50.7M|      }
  165|  50.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|  50.7M|      {
   73|  50.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|  50.7M|         else {
   84|  50.7M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  50.7M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  50.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|  50.7M|      {
   59|  50.7M|         return Rule::match( in );
   60|  50.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|   146k|   {
  104|   146k|      if constexpr( !Control< Rule >::enable ) {
  105|   146k|         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|   146k|   }
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|   146k|      {
   44|   146k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   146k|      }
_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|   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: 146k, False: 111]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|   146k|            else if constexpr( has_apply0_bool ) {
  153|   146k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|   146k|            }
  155|   146k|         }
  156|   146k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 146k, False: 111]
  ------------------
  157|   146k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|   146k|         }
  159|    111|         else {
  160|    111|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    111|         }
  162|   146k|         (void)m( result );
  163|   146k|         return result;
  164|   146k|      }
  165|   146k|   }
_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|   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_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|   146k|      {
   44|   146k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   146k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_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: 33.2k, False: 113k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.2k|            else if constexpr( has_apply0_bool ) {
  153|  33.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.2k|            }
  155|  33.2k|         }
  156|   146k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.2k, False: 113k]
  ------------------
  157|  33.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.2k|         }
  159|   113k|         else {
  160|   113k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   113k|         }
  162|   146k|         (void)m( result );
  163|   146k|         return result;
  164|   146k|      }
  165|   146k|   }
_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|   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_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|   146k|      {
   44|   146k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   146k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_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: 33.2k, False: 113k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.2k|            else if constexpr( has_apply0_bool ) {
  153|  33.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.2k|            }
  155|  33.2k|         }
  156|   146k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.2k, False: 113k]
  ------------------
  157|  33.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.2k|         }
  159|   113k|         else {
  160|   113k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   113k|         }
  162|   146k|         (void)m( result );
  163|   146k|         return result;
  164|   146k|      }
  165|   146k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_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_controlINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   146k|      {
   59|   146k|         return Rule::match( in );
   60|   146k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  33.2k|   {
  104|  33.2k|      if constexpr( !Control< Rule >::enable ) {
  105|  33.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|  33.2k|   }
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|  33.2k|      {
   44|  33.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.2k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  33.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  33.2k|      else {
  108|  33.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  33.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  33.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|  33.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|  33.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|  33.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|  33.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|  33.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|  33.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  33.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  33.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  33.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|  33.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  33.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  33.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|  33.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  33.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  33.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  33.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  33.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 33.2k, False: 36]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.2k|            else if constexpr( has_apply0_bool ) {
  153|  33.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  33.2k|            }
  155|  33.2k|         }
  156|  33.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 33.2k, False: 36]
  ------------------
  157|  33.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  33.2k|         }
  159|     36|         else {
  160|     36|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     36|         }
  162|  33.2k|         (void)m( result );
  163|  33.2k|         return result;
  164|  33.2k|      }
  165|  33.2k|   }
_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|  33.2k|      {
   73|  33.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|  33.2k|         else {
   84|  33.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  33.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  33.2k|      }
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|  33.2k|      {
   44|  33.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  33.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  66.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  66.5k|      else {
  108|  66.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  66.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  66.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|  66.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|  66.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|  66.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|  66.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|  66.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|  66.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  66.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  66.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  66.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|  66.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  66.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  66.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|  66.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  66.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  66.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  66.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  66.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 66.4k, False: 36]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.4k|            else if constexpr( has_apply0_bool ) {
  153|  66.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  66.4k|            }
  155|  66.4k|         }
  156|  66.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 66.4k, False: 36]
  ------------------
  157|  66.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  66.4k|         }
  159|     36|         else {
  160|     36|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     36|         }
  162|  66.5k|         (void)m( result );
  163|  66.5k|         return result;
  164|  66.5k|      }
  165|  66.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  66.5k|      {
   73|  66.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|  66.5k|         else {
   84|  66.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  66.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  66.5k|      }
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|  66.5k|      {
   59|  66.5k|         return Rule::match( in );
   60|  66.5k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|   113k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   113k|      else {
  108|   113k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   113k|         using iterator_t = typename ParseInput::iterator_t;
  111|   113k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   113k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   113k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   113k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   113k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   113k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   113k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   113k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   113k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   113k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   113k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   113k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   113k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   113k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   113k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   113k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   113k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   113k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 31.4k, False: 81.9k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.4k|            else if constexpr( has_apply0_bool ) {
  153|  31.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  31.4k|            }
  155|  31.4k|         }
  156|   113k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 31.4k, False: 81.9k]
  ------------------
  157|  31.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  31.4k|         }
  159|  81.9k|         else {
  160|  81.9k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  81.9k|         }
  162|   113k|         (void)m( result );
  163|   113k|         return result;
  164|   113k|      }
  165|   113k|   }
_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|   113k|      {
   73|   113k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   113k|         else {
   84|   113k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   113k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   113k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_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|   113k|      {
   44|   113k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|   113k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|   155k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|   155k|      else {
  108|   155k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|   155k|         using iterator_t = typename ParseInput::iterator_t;
  111|   155k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|   155k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|   155k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|   155k|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|   155k|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|   155k|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|   155k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|   155k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|   155k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|   155k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|   155k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|   155k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|   155k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|   155k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|   155k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|   155k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|   155k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|   155k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 43.4k, False: 111k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  43.4k|            else if constexpr( has_apply0_bool ) {
  153|  43.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  43.4k|            }
  155|  43.4k|         }
  156|   155k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 43.4k, False: 111k]
  ------------------
  157|  43.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  43.4k|         }
  159|   111k|         else {
  160|   111k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|   111k|         }
  162|   155k|         (void)m( result );
  163|   155k|         return result;
  164|   155k|      }
  165|   155k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|   155k|      {
   73|   155k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|   155k|         else {
   84|   155k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|   155k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|   155k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_controlINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDTclsrT_5matchfp_EERT4_DpOT5_:
   58|   155k|      {
   59|   155k|         return Rule::match( in );
   60|   155k|      }
_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|  31.4k|   {
  104|  31.4k|      if constexpr( !Control< Rule >::enable ) {
  105|  31.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|  31.4k|   }
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|  31.4k|      {
   44|  31.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  31.4k|      }
_ZN3tao5pegtl5matchINS0_7rep_optILj2EJNS0_5ascii5digitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  31.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  31.4k|      else {
  108|  31.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  31.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  31.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|  31.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|  31.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|  31.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|  31.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|  31.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|  31.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  31.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  31.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  31.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|  31.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  31.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  31.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|  31.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  31.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  31.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  31.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  31.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 31.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|  31.4k|            else if constexpr( has_apply0_bool ) {
  153|  31.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  31.4k|            }
  155|  31.4k|         }
  156|  31.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 31.4k, False: 0]
  ------------------
  157|  31.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  31.4k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  31.4k|         (void)m( result );
  163|  31.4k|         return result;
  164|  31.4k|      }
  165|  31.4k|   }
_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|  31.4k|      {
   73|  31.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|  31.4k|         else {
   84|  31.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  31.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  31.4k|      }
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|  31.4k|      {
   44|  31.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  31.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser14escaped_singleELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  81.9k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  81.9k|      else {
  108|  81.9k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  81.9k|         using iterator_t = typename ParseInput::iterator_t;
  111|  81.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|  81.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|  81.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|  81.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|  81.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|  81.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|  81.9k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  81.9k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  81.9k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  81.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|  81.9k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  81.9k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  81.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|  81.9k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  81.9k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  81.9k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  81.9k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  81.9k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 81.6k, False: 288]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  81.6k|            else if constexpr( has_apply0_bool ) {
  153|  81.6k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  81.6k|            }
  155|  81.6k|         }
  156|  81.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 81.6k, False: 288]
  ------------------
  157|  81.6k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  81.6k|         }
  159|    288|         else {
  160|    288|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    288|         }
  162|  81.9k|         (void)m( result );
  163|  81.9k|         return result;
  164|  81.9k|      }
  165|  81.9k|   }
_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|  81.9k|      {
   73|  81.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|  81.9k|         else {
   84|  81.9k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  81.9k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  81.9k|      }
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|  81.9k|      {
   59|  81.9k|         return Rule::match( in );
   60|  81.9k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|    288|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|    288|      else {
  108|    288|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|    288|         using iterator_t = typename ParseInput::iterator_t;
  111|    288|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|    288|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|    288|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [Folded, False: 0]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|    288|         constexpr bool has_apply0_void = enable_action && internal::has_apply0< Control< Rule >, void, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (115:43): [True: 0, Folded]
  |  Branch (115:60): [Folded, False: 0]
  ------------------
  116|    288|         constexpr bool has_apply0_bool = enable_action && internal::has_apply0< Control< Rule >, bool, Action, const ParseInput&, States... >;
  ------------------
  |  Branch (116:43): [True: 0, Folded]
  |  Branch (116:60): [Folded, False: 0]
  ------------------
  117|    288|         constexpr bool has_apply0 = has_apply0_void || has_apply0_bool;
  ------------------
  |  Branch (117:38): [Folded, False: 0]
  |  Branch (117:57): [Folded, False: 0]
  ------------------
  118|       |
  119|    288|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|    288|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|    288|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|    288|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if constexpr( !has_apply0 && std::is_base_of_v< require_apply0, Action< Rule > > ) {
  130|       |            internal::missing_apply0< Control< Rule >, Action >( in, st... );
  131|       |         }
  132|       |
  133|    288|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|    288|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|    288|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|    288|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|    288|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|    288|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|    288|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|    288|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 213, 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|    213|            else if constexpr( has_apply0_bool ) {
  153|    213|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    213|            }
  155|    213|         }
  156|    288|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 213, False: 75]
  ------------------
  157|    213|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    213|         }
  159|     75|         else {
  160|     75|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     75|         }
  162|    288|         (void)m( result );
  163|    288|         return result;
  164|    288|      }
  165|    288|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc41EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|    288|      {
   73|    288|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, A, M, Action, Control >( in, st... );
   77|       |            }
   78|       |            catch( ... ) {
   79|       |               Control< Rule >::unwind( static_cast< const ParseInput& >( in ), st... );
   80|       |               throw;
   81|       |            }
   82|       |         }
   83|    288|         else {
   84|    288|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|    288|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|    288|      }
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|    288|      {
   59|    288|         return Rule::match( in );
   60|    288|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  50.5M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  50.5M|      else {
  108|  50.5M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  50.5M|         using iterator_t = typename ParseInput::iterator_t;
  111|  50.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|  50.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|  50.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|  50.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|  50.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|  50.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|  50.5M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  50.5M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  50.5M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  50.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|  50.5M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  50.5M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  50.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|  50.5M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  50.5M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  50.5M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  50.5M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  50.5M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 50.5M, False: 277]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  50.5M|            else if constexpr( has_apply0_bool ) {
  153|  50.5M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  50.5M|            }
  155|  50.5M|         }
  156|  50.5M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 50.5M, False: 277]
  ------------------
  157|  50.5M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  50.5M|         }
  159|    277|         else {
  160|    277|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    277|         }
  162|  50.5M|         (void)m( result );
  163|  50.5M|         return result;
  164|  50.5M|      }
  165|  50.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|  50.5M|      {
   73|  50.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|  50.5M|         else {
   84|  50.5M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  50.5M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  50.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|  50.5M|      {
   59|  50.5M|         return Rule::match( in );
   60|  50.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|  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: 3.43k, False: 10.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|  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|  13.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.43k, False: 10.5k]
  ------------------
  157|  3.43k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.43k|         }
  159|  10.5k|         else {
  160|  10.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.5k|         }
  162|  13.9k|         (void)m( result );
  163|  13.9k|         return result;
  164|  13.9k|      }
  165|  13.9k|   }
_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|  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_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|  13.9k|      {
   44|  13.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  13.9k|      }
_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|  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: 3.43k, False: 10.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|  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|  13.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.43k, False: 10.5k]
  ------------------
  157|  3.43k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.43k|         }
  159|  10.5k|         else {
  160|  10.5k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  10.5k|         }
  162|  13.9k|         (void)m( result );
  163|  13.9k|         return result;
  164|  13.9k|      }
  165|  13.9k|   }
_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|  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_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|  13.9k|      {
   44|  13.9k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  13.9k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9str_labelELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_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: 4.09k, False: 9.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|  4.09k|            else if constexpr( has_apply0_bool ) {
  153|  4.09k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.09k|            }
  155|  4.09k|         }
  156|  13.9k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.09k, False: 9.90k]
  ------------------
  157|  4.09k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.09k|         }
  159|  9.90k|         else {
  160|  9.90k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.90k|         }
  162|  13.9k|         (void)m( result );
  163|  13.9k|         return result;
  164|  13.9k|      }
  165|  13.9k|   }
_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|  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_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|  13.9k|      {
   59|  13.9k|         return Rule::match( in );
   60|  13.9k|      }
_ZN3tao5pegtl5matchINS0_4plusINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  9.86k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.86k|      else {
  108|  9.86k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.86k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.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|  9.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|  9.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|  9.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|  9.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|  9.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|  9.86k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.86k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.86k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.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|  9.86k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.86k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.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|  9.86k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.86k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.86k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.86k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.86k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.00k, False: 1.86k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.00k|            else if constexpr( has_apply0_bool ) {
  153|  8.00k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.00k|            }
  155|  8.00k|         }
  156|  9.86k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.00k, False: 1.86k]
  ------------------
  157|  8.00k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.00k|         }
  159|  1.86k|         else {
  160|  1.86k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.86k|         }
  162|  9.86k|         (void)m( result );
  163|  9.86k|         return result;
  164|  9.86k|      }
  165|  9.86k|   }
_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|  9.86k|      {
   73|  9.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|  9.86k|         else {
   84|  9.86k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.86k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.86k|      }
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|  9.86k|      {
   44|  9.86k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.86k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  9.86k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.86k|      else {
  108|  9.86k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.86k|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.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|  9.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|  9.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|  9.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|  9.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|  9.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|  9.86k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.86k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.86k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.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|  9.86k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.86k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.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|  9.86k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.86k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.86k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.86k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.86k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 8.00k, False: 1.86k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.00k|            else if constexpr( has_apply0_bool ) {
  153|  8.00k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  8.00k|            }
  155|  8.00k|         }
  156|  9.86k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 8.00k, False: 1.86k]
  ------------------
  157|  8.00k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  8.00k|         }
  159|  1.86k|         else {
  160|  1.86k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.86k|         }
  162|  9.86k|         (void)m( result );
  163|  9.86k|         return result;
  164|  9.86k|      }
  165|  9.86k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  9.86k|      {
   73|  9.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|  9.86k|         else {
   84|  9.86k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.86k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.86k|      }
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|  9.86k|      {
   59|  9.86k|         return Rule::match( in );
   60|  9.86k|      }
_ZN3tao5pegtl5matchINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  15.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  15.8k|      else {
  108|  15.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  15.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  15.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|  15.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|  15.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|  15.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|  15.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|  15.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|  15.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  15.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  15.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  15.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|  15.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  15.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  15.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|  15.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  15.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  15.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  15.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  15.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.18k, False: 12.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|  3.18k|            else if constexpr( has_apply0_bool ) {
  153|  3.18k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  3.18k|            }
  155|  3.18k|         }
  156|  15.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.18k, False: 12.6k]
  ------------------
  157|  3.18k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.18k|         }
  159|  12.6k|         else {
  160|  12.6k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  12.6k|         }
  162|  15.8k|         (void)m( result );
  163|  15.8k|         return result;
  164|  15.8k|      }
  165|  15.8k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5blankELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  15.8k|      {
   73|  15.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|  15.8k|         else {
   84|  15.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  15.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  15.8k|      }
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|  15.8k|      {
   59|  15.8k|         return Rule::match( in );
   60|  15.8k|      }
_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.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.07k|      else {
  108|  4.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 3.43k, False: 633]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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|  4.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 3.43k, False: 633]
  ------------------
  157|  3.43k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  3.43k|         }
  159|    633|         else {
  160|    633|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    633|         }
  162|  4.07k|         (void)m( result );
  163|  4.07k|         return result;
  164|  4.07k|      }
  165|  4.07k|   }
_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.07k|      {
   73|  4.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|  4.07k|         else {
   84|  4.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.07k|      }
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.07k|      {
   44|  4.07k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.07k|      }
_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.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.07k|      else {
  108|  4.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.17k, False: 1.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|  2.17k|            else if constexpr( has_apply0_bool ) {
  153|  2.17k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.17k|            }
  155|  2.17k|         }
  156|  4.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.17k, False: 1.89k]
  ------------------
  157|  2.17k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.17k|         }
  159|  1.89k|         else {
  160|  1.89k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.89k|         }
  162|  4.07k|         (void)m( result );
  163|  4.07k|         return result;
  164|  4.07k|      }
  165|  4.07k|   }
_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.07k|      {
   73|  4.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|  4.07k|         else {
   84|  4.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.07k|      }
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.07k|      {
   44|  4.07k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.07k|      }
_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.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.07k|      else {
  108|  4.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.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|  4.07k|            else if constexpr( has_apply0_bool ) {
  153|  4.07k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.07k|            }
  155|  4.07k|         }
  156|  4.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.07k, False: 0]
  ------------------
  157|  4.07k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.07k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.07k|         (void)m( result );
  163|  4.07k|         return result;
  164|  4.07k|      }
  165|  4.07k|   }
_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.07k|      {
   73|  4.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|  4.07k|         else {
   84|  4.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.07k|      }
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.07k|      {
   44|  4.07k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.07k|      }
_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.07k|   {
  104|  4.07k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.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|  4.07k|   }
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.07k|      {
   44|  4.07k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.07k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17multiset_operatorELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  4.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.07k|      else {
  108|  4.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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): [True: 0, Folded]
  ------------------
  112|  4.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|  4.07k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 4.07k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  4.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|  4.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|  4.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|  4.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 4.07k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.44k, False: 2.62k]
  ------------------
  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.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.44k, False: 2.62k]
  ------------------
  157|  1.44k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.44k|         }
  159|  2.62k|         else {
  160|  2.62k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.62k|         }
  162|  4.07k|         (void)m( result );
  163|  4.07k|         return result;
  164|  4.07k|      }
  165|  4.07k|   }
_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.07k|      {
   73|  4.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|  4.07k|         else {
   84|  4.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.07k|      }
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.07k|      {
   44|  4.07k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.07k|      }
_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.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.07k|      else {
  108|  4.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 360, False: 3.71k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    360|            else if constexpr( has_apply0_bool ) {
  153|    360|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    360|            }
  155|    360|         }
  156|  4.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 360, False: 3.71k]
  ------------------
  157|    360|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    360|         }
  159|  3.71k|         else {
  160|  3.71k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.71k|         }
  162|  4.07k|         (void)m( result );
  163|  4.07k|         return result;
  164|  4.07k|      }
  165|  4.07k|   }
_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.07k|      {
   73|  4.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|  4.07k|         else {
   84|  4.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.07k|      }
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.07k|      {
   59|  4.07k|         return Rule::match( in );
   60|  4.07k|      }
_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.71k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.71k|      else {
  108|  3.71k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.71k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.71k|         constexpr bool has_apply_void = enable_action && internal::has_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.71k|         constexpr bool has_apply_bool = enable_action && internal::has_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.71k|         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.71k|         constexpr bool has_apply0_void = enable_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.71k|         constexpr bool has_apply0_bool = enable_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.71k|         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.71k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.71k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.71k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.71k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.71k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.71k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.71k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.71k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.71k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.71k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.71k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.71k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 245, False: 3.46k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|    245|            else if constexpr( has_apply0_bool ) {
  153|    245|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    245|            }
  155|    245|         }
  156|  3.71k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 245, False: 3.46k]
  ------------------
  157|    245|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    245|         }
  159|  3.46k|         else {
  160|  3.46k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.46k|         }
  162|  3.71k|         (void)m( result );
  163|  3.71k|         return result;
  164|  3.71k|      }
  165|  3.71k|   }
_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.71k|      {
   73|  3.71k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.71k|         else {
   84|  3.71k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.71k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.71k|      }
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.71k|      {
   59|  3.71k|         return Rule::match( in );
   60|  3.71k|      }
_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.46k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.46k|      else {
  108|  3.46k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.46k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.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|  3.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|  3.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|  3.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|  3.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|  3.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|  3.46k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.46k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.46k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.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|  3.46k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.46k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.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|  3.46k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.46k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.46k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.46k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.46k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 67, False: 3.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|     67|            else if constexpr( has_apply0_bool ) {
  153|     67|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|     67|            }
  155|     67|         }
  156|  3.46k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 67, False: 3.39k]
  ------------------
  157|     67|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|     67|         }
  159|  3.39k|         else {
  160|  3.39k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.39k|         }
  162|  3.46k|         (void)m( result );
  163|  3.46k|         return result;
  164|  3.46k|      }
  165|  3.46k|   }
_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.46k|      {
   73|  3.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|  3.46k|         else {
   84|  3.46k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.46k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.46k|      }
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.46k|      {
   59|  3.46k|         return Rule::match( in );
   60|  3.46k|      }
_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.39k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  3.39k|      else {
  108|  3.39k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  3.39k|         using iterator_t = typename ParseInput::iterator_t;
  111|  3.39k|         constexpr bool has_apply_void = enable_action && internal::has_apply< Control< Rule >, void, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (111:42): [True: 0, Folded]
  |  Branch (111:59): [Folded, False: 0]
  ------------------
  112|  3.39k|         constexpr bool has_apply_bool = enable_action && internal::has_apply< Control< Rule >, bool, Action, const iterator_t&, const ParseInput&, States... >;
  ------------------
  |  Branch (112:42): [True: 0, Folded]
  |  Branch (112:59): [Folded, False: 0]
  ------------------
  113|  3.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|  3.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|  3.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|  3.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|  3.39k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  3.39k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  3.39k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  3.39k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.39k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  3.39k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  3.39k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  3.39k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  3.39k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  3.39k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  3.39k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  3.39k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 194, 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|    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.39k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 194, False: 3.20k]
  ------------------
  157|    194|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    194|         }
  159|  3.20k|         else {
  160|  3.20k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  3.20k|         }
  162|  3.39k|         (void)m( result );
  163|  3.39k|         return result;
  164|  3.39k|      }
  165|  3.39k|   }
_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.39k|      {
   73|  3.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|  3.39k|         else {
   84|  3.39k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  3.39k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  3.39k|      }
RuleParser.cpp:_ZN3tao5pegtl8internalL16match_no_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.39k|      {
   59|  3.39k|         return Rule::match( in );
   60|  3.39k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser10str_equalsELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_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: 299, False: 2.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|    299|            else if constexpr( has_apply0_bool ) {
  153|    299|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    299|            }
  155|    299|         }
  156|  3.20k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 299, False: 2.90k]
  ------------------
  157|    299|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    299|         }
  159|  2.90k|         else {
  160|  2.90k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.90k|         }
  162|  3.20k|         (void)m( result );
  163|  3.20k|         return result;
  164|  3.20k|      }
  165|  3.20k|   }
_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.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_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.20k|      {
   59|  3.20k|         return Rule::match( in );
   60|  3.20k|      }
_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.90k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.90k|      else {
  108|  2.90k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.90k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.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|  2.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|  2.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|  2.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|  2.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|  2.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|  2.90k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.90k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.90k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.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|  2.90k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.90k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.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|  2.90k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.90k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.90k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.90k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.90k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 279, 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|    279|            else if constexpr( has_apply0_bool ) {
  153|    279|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|    279|            }
  155|    279|         }
  156|  2.90k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 279, False: 2.62k]
  ------------------
  157|    279|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|    279|         }
  159|  2.62k|         else {
  160|  2.62k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  2.62k|         }
  162|  2.90k|         (void)m( result );
  163|  2.90k|         return result;
  164|  2.90k|      }
  165|  2.90k|   }
_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.90k|      {
   73|  2.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|  2.90k|         else {
   84|  2.90k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.90k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.90k|      }
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.90k|      {
   59|  2.90k|         return Rule::match( in );
   60|  2.90k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc123EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  4.07k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.07k|      else {
  108|  4.07k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.07k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.07k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.07k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.07k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.07k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.07k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.07k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.07k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.07k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.07k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.07k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.36k, False: 1.70k]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.36k|            else if constexpr( has_apply0_bool ) {
  153|  2.36k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.36k|            }
  155|  2.36k|         }
  156|  4.07k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.36k, False: 1.70k]
  ------------------
  157|  2.36k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.36k|         }
  159|  1.70k|         else {
  160|  1.70k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.70k|         }
  162|  4.07k|         (void)m( result );
  163|  4.07k|         return result;
  164|  4.07k|      }
  165|  4.07k|   }
_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.07k|      {
   73|  4.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|  4.07k|         else {
   84|  4.07k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.07k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.07k|      }
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.07k|      {
   59|  4.07k|         return Rule::match( in );
   60|  4.07k|      }
_ZN3tao5pegtl5matchINS0_4starINS0_5ascii5blankEJEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  4.65k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  4.65k|      else {
  108|  4.65k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  4.65k|         using iterator_t = typename ParseInput::iterator_t;
  111|  4.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|  4.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|  4.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|  4.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|  4.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|  4.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|  4.65k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  4.65k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  4.65k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  4.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|  4.65k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  4.65k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  4.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|  4.65k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  4.65k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  4.65k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  4.65k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  4.65k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 4.65k, 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.65k|            else if constexpr( has_apply0_bool ) {
  153|  4.65k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  4.65k|            }
  155|  4.65k|         }
  156|  4.65k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 4.65k, False: 0]
  ------------------
  157|  4.65k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  4.65k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  4.65k|         (void)m( result );
  163|  4.65k|         return result;
  164|  4.65k|      }
  165|  4.65k|   }
_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.65k|      {
   73|  4.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|  4.65k|         else {
   84|  4.65k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  4.65k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  4.65k|      }
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.65k|      {
   44|  4.65k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.65k|      }
_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.36k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.36k|      else {
  108|  2.36k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.36k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.36k|         constexpr bool has_apply_void = enable_action && internal::has_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.36k|         constexpr bool has_apply_bool = enable_action && internal::has_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.36k|         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.36k|         constexpr bool has_apply0_void = enable_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.36k|         constexpr bool has_apply0_bool = enable_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.36k|         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.36k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.36k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.36k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.36k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.36k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.36k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.36k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.36k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.36k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.36k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.36k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.36k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.29k, 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.29k|            else if constexpr( has_apply0_bool ) {
  153|  2.29k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.29k|            }
  155|  2.29k|         }
  156|  2.36k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.29k, False: 75]
  ------------------
  157|  2.29k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.29k|         }
  159|     75|         else {
  160|     75|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     75|         }
  162|  2.36k|         (void)m( result );
  163|  2.36k|         return result;
  164|  2.36k|      }
  165|  2.36k|   }
_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.36k|      {
   73|  2.36k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.36k|         else {
   84|  2.36k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.36k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.36k|      }
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.36k|      {
   44|  2.36k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.36k|      }
_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.29k|   {
  104|  2.29k|      if constexpr( !Control< Rule >::enable ) {
  105|  2.29k|         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.29k|   }
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.29k|      {
   44|  2.29k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  2.29k|      }
_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.32k|   {
  104|  4.32k|      if constexpr( !Control< Rule >::enable ) {
  105|  4.32k|         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.32k|   }
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.32k|      {
   44|  4.32k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  4.32k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc125EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  2.29k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  2.29k|      else {
  108|  2.29k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  2.29k|         using iterator_t = typename ParseInput::iterator_t;
  111|  2.29k|         constexpr bool has_apply_void = enable_action && internal::has_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.29k|         constexpr bool has_apply_bool = enable_action && internal::has_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.29k|         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.29k|         constexpr bool has_apply0_void = enable_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.29k|         constexpr bool has_apply0_bool = enable_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.29k|         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.29k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  2.29k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  2.29k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  2.29k|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.29k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  2.29k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  2.29k|         static_assert( !enable_action || !validate_nothing || is_nothing || is_maybe_nothing || has_apply || has_apply0, "either apply() or apply0() must be defined" );
  136|       |
  137|  2.29k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  2.29k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  2.29k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  2.29k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  2.29k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 2.17k, False: 111]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.17k|            else if constexpr( has_apply0_bool ) {
  153|  2.17k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  2.17k|            }
  155|  2.17k|         }
  156|  2.29k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 2.17k, False: 111]
  ------------------
  157|  2.17k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  2.17k|         }
  159|    111|         else {
  160|    111|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    111|         }
  162|  2.29k|         (void)m( result );
  163|  2.29k|         return result;
  164|  2.29k|      }
  165|  2.29k|   }
_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.29k|      {
   73|  2.29k|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.29k|         else {
   84|  2.29k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  2.29k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  2.29k|      }
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.29k|      {
   59|  2.29k|         return Rule::match( in );
   60|  2.29k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser12string_valueELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  6.77k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.77k|      else {
  108|  6.77k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.77k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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): [True: 0, Folded]
  ------------------
  112|  6.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|  6.77k|         constexpr bool has_apply = has_apply_void || has_apply_bool;
  ------------------
  |  Branch (113:37): [True: 6.77k, Folded]
  |  Branch (113:55): [Folded, False: 0]
  ------------------
  114|       |
  115|  6.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|  6.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|  6.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|  6.77k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.77k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.77k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.77k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.77k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.77k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [True: 6.77k, Folded]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.77k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.77k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.77k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.77k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.61k, False: 1.16k]
  ------------------
  143|  5.61k|            if constexpr( has_apply_void ) {
  144|  5.61k|               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.61k|         }
  156|  6.77k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.58k, False: 1.19k]
  ------------------
  157|  5.58k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.58k|         }
  159|  1.19k|         else {
  160|  1.19k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.19k|         }
  162|  6.77k|         (void)m( result );
  163|  6.77k|         return result;
  164|  6.77k|      }
  165|  6.77k|   }
_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|  6.77k|      {
   73|  6.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|  6.77k|         else {
   84|  6.77k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.77k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.77k|      }
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|  6.77k|      {
   44|  6.77k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  6.77k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  6.77k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  6.77k|      else {
  108|  6.77k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  6.77k|         using iterator_t = typename ParseInput::iterator_t;
  111|  6.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|  6.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|  6.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|  6.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|  6.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|  6.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|  6.77k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  6.77k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  6.77k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  6.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|  6.77k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  6.77k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  6.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|  6.77k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  6.77k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  6.77k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  6.77k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  6.77k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.89k, False: 885]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.89k|            else if constexpr( has_apply0_bool ) {
  153|  5.89k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.89k|            }
  155|  5.89k|         }
  156|  6.77k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.89k, False: 885]
  ------------------
  157|  5.89k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.89k|         }
  159|    885|         else {
  160|    885|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    885|         }
  162|  6.77k|         (void)m( result );
  163|  6.77k|         return result;
  164|  6.77k|      }
  165|  6.77k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  6.77k|      {
   73|  6.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|  6.77k|         else {
   84|  6.77k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  6.77k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  6.77k|      }
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|  6.77k|      {
   59|  6.77k|         return Rule::match( in );
   60|  6.77k|      }
_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|  5.89k|   {
  104|  5.89k|      if constexpr( !Control< Rule >::enable ) {
  105|  5.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|  5.89k|   }
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|  5.89k|      {
   44|  5.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.89k|      }
_ZN3tao5pegtl5matchINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  5.89k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  5.89k|      else {
  108|  5.89k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  5.89k|         using iterator_t = typename ParseInput::iterator_t;
  111|  5.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|  5.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|  5.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|  5.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|  5.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|  5.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|  5.89k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  5.89k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  5.89k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  5.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|  5.89k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  5.89k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  5.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|  5.89k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  5.89k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  5.89k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  5.89k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  5.89k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.61k, False: 276]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.61k|            else if constexpr( has_apply0_bool ) {
  153|  5.61k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.61k|            }
  155|  5.61k|         }
  156|  5.89k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.61k, False: 276]
  ------------------
  157|  5.61k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.61k|         }
  159|    276|         else {
  160|    276|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    276|         }
  162|  5.89k|         (void)m( result );
  163|  5.89k|         return result;
  164|  5.89k|      }
  165|  5.89k|   }
_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|  5.89k|      {
   73|  5.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|  5.89k|         else {
   84|  5.89k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  5.89k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  5.89k|      }
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|  5.89k|      {
   44|  5.89k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  5.89k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.38M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.38M|      else {
  108|  9.38M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.38M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.38M|         constexpr bool has_apply_void = enable_action && internal::has_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.38M|         constexpr bool has_apply_bool = enable_action && internal::has_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.38M|         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.38M|         constexpr bool has_apply0_void = enable_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.38M|         constexpr bool has_apply0_bool = enable_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.38M|         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.38M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.38M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.38M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.38M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.38M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.38M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.38M|         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.38M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.38M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.38M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.38M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.38M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 5.61k, False: 9.38M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.61k|            else if constexpr( has_apply0_bool ) {
  153|  5.61k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  5.61k|            }
  155|  5.61k|         }
  156|  9.38M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 5.61k, False: 9.38M]
  ------------------
  157|  5.61k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  5.61k|         }
  159|  9.38M|         else {
  160|  9.38M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.38M|         }
  162|  9.38M|         (void)m( result );
  163|  9.38M|         return result;
  164|  9.38M|      }
  165|  9.38M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  9.38M|      {
   73|  9.38M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.38M|         else {
   84|  9.38M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.38M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.38M|      }
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|  9.38M|      {
   59|  9.38M|         return Rule::match( in );
   60|  9.38M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.38M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.38M|      else {
  108|  9.38M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.38M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.38M|         constexpr bool has_apply_void = enable_action && internal::has_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.38M|         constexpr bool has_apply_bool = enable_action && internal::has_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.38M|         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.38M|         constexpr bool has_apply0_void = enable_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.38M|         constexpr bool has_apply0_bool = enable_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.38M|         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.38M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.38M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.38M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.38M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.38M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.38M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.38M|         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.38M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.38M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.38M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.38M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.38M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.38M, False: 276]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.38M|            else if constexpr( has_apply0_bool ) {
  153|  9.38M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.38M|            }
  155|  9.38M|         }
  156|  9.38M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.38M, False: 276]
  ------------------
  157|  9.38M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.38M|         }
  159|    276|         else {
  160|    276|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    276|         }
  162|  9.38M|         (void)m( result );
  163|  9.38M|         return result;
  164|  9.38M|      }
  165|  9.38M|   }
_ZN3tao5pegtl8internal20match_control_unwindIN8usbguard10RuleParser9characterILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS4_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
   72|  9.38M|      {
   73|  9.38M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.38M|         else {
   84|  9.38M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.38M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.38M|      }
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|  9.38M|      {
   44|  9.38M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.38M|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_escapedILc34EEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.38M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.38M|      else {
  108|  9.38M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.38M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.38M|         constexpr bool has_apply_void = enable_action && internal::has_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.38M|         constexpr bool has_apply_bool = enable_action && internal::has_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.38M|         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.38M|         constexpr bool has_apply0_void = enable_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.38M|         constexpr bool has_apply0_bool = enable_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.38M|         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.38M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.38M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.38M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.38M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.38M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.38M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.38M|         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.38M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.38M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.38M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.38M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.38M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 96.9k, False: 9.28M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.9k|            else if constexpr( has_apply0_bool ) {
  153|  96.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  96.9k|            }
  155|  96.9k|         }
  156|  9.38M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 96.9k, False: 9.28M]
  ------------------
  157|  96.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  96.9k|         }
  159|  9.28M|         else {
  160|  9.28M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.28M|         }
  162|  9.38M|         (void)m( result );
  163|  9.38M|         return result;
  164|  9.38M|      }
  165|  9.38M|   }
_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|  9.38M|      {
   73|  9.38M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.38M|         else {
   84|  9.38M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.38M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.38M|      }
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|  9.38M|      {
   44|  9.38M|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  9.38M|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  9.38M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.38M|      else {
  108|  9.38M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.38M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.38M|         constexpr bool has_apply_void = enable_action && internal::has_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.38M|         constexpr bool has_apply_bool = enable_action && internal::has_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.38M|         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.38M|         constexpr bool has_apply0_void = enable_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.38M|         constexpr bool has_apply0_bool = enable_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.38M|         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.38M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.38M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.38M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.38M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.38M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.38M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.38M|         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.38M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.38M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.38M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.38M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.38M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 97.0k, False: 9.28M]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  148|       |            }
  149|       |            else if constexpr( has_apply0_void ) {
  150|       |               Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  151|       |            }
  152|  97.0k|            else if constexpr( has_apply0_bool ) {
  153|  97.0k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  97.0k|            }
  155|  97.0k|         }
  156|  9.38M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 97.0k, False: 9.28M]
  ------------------
  157|  97.0k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  97.0k|         }
  159|  9.28M|         else {
  160|  9.28M|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  9.28M|         }
  162|  9.38M|         (void)m( result );
  163|  9.38M|         return result;
  164|  9.38M|      }
  165|  9.38M|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc92EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  9.38M|      {
   73|  9.38M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.38M|         else {
   84|  9.38M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.38M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.38M|      }
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|  9.38M|      {
   59|  9.38M|         return Rule::match( in );
   60|  9.38M|      }
_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|  97.0k|   {
  104|  97.0k|      if constexpr( !Control< Rule >::enable ) {
  105|  97.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|  97.0k|   }
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|  97.0k|      {
   44|  97.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  97.0k|      }
_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|  97.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  97.0k|      else {
  108|  97.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  97.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  97.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|  97.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|  97.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|  97.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|  97.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|  97.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|  97.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  97.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  97.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  97.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|  97.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  97.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  97.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|  97.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  97.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  97.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  97.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  97.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 96.9k, False: 109]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.9k|            else if constexpr( has_apply0_bool ) {
  153|  96.9k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  96.9k|            }
  155|  96.9k|         }
  156|  97.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 96.9k, False: 109]
  ------------------
  157|  96.9k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  96.9k|         }
  159|    109|         else {
  160|    109|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    109|         }
  162|  97.0k|         (void)m( result );
  163|  97.0k|         return result;
  164|  97.0k|      }
  165|  97.0k|   }
_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|  97.0k|      {
   73|  97.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|  97.0k|         else {
   84|  97.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  97.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  97.0k|      }
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|  97.0k|      {
   44|  97.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  97.0k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_hexbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  97.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  97.0k|      else {
  108|  97.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  97.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  97.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|  97.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|  97.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|  97.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|  97.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|  97.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|  97.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  97.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  97.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  97.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|  97.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  97.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  97.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|  97.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  97.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  97.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  97.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  97.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.1k, False: 59.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|  37.1k|            else if constexpr( has_apply0_bool ) {
  153|  37.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.1k|            }
  155|  37.1k|         }
  156|  97.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.1k, False: 59.8k]
  ------------------
  157|  37.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.1k|         }
  159|  59.8k|         else {
  160|  59.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  59.8k|         }
  162|  97.0k|         (void)m( result );
  163|  97.0k|         return result;
  164|  97.0k|      }
  165|  97.0k|   }
_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|  97.0k|      {
   73|  97.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|  97.0k|         else {
   84|  97.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  97.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  97.0k|      }
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|  97.0k|      {
   44|  97.0k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  97.0k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  97.0k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  97.0k|      else {
  108|  97.0k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  97.0k|         using iterator_t = typename ParseInput::iterator_t;
  111|  97.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|  97.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|  97.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|  97.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|  97.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|  97.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|  97.0k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  97.0k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  97.0k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  97.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|  97.0k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  97.0k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  97.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|  97.0k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  97.0k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  97.0k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  97.0k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  97.0k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.2k, False: 59.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|  37.2k|            else if constexpr( has_apply0_bool ) {
  153|  37.2k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.2k|            }
  155|  37.2k|         }
  156|  97.0k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.2k, False: 59.8k]
  ------------------
  157|  37.2k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.2k|         }
  159|  59.8k|         else {
  160|  59.8k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  59.8k|         }
  162|  97.0k|         (void)m( result );
  163|  97.0k|         return result;
  164|  97.0k|      }
  165|  97.0k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii3oneIJLc120EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
   72|  97.0k|      {
   73|  97.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|  97.0k|         else {
   84|  97.0k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  97.0k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  97.0k|      }
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|  97.0k|      {
   59|  97.0k|         return Rule::match( in );
   60|  97.0k|      }
_ZN3tao5pegtl5matchINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNSB_4RuleEEEEDaRT4_DpOT5_:
  103|  37.2k|   {
  104|  37.2k|      if constexpr( !Control< Rule >::enable ) {
  105|  37.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|  37.2k|   }
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|  37.2k|      {
   44|  37.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.2k|      }
_ZN3tao5pegtl5matchINS0_3repILj2EJNS0_5ascii6xdigitEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS8_4RuleEEEEDaRT4_DpOT5_:
  103|  37.2k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  37.2k|      else {
  108|  37.2k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  37.2k|         using iterator_t = typename ParseInput::iterator_t;
  111|  37.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|  37.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|  37.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|  37.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|  37.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|  37.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|  37.2k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  37.2k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  37.2k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  37.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|  37.2k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  37.2k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  37.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|  37.2k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  37.2k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  37.2k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  37.2k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  37.2k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 37.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|  37.1k|            else if constexpr( has_apply0_bool ) {
  153|  37.1k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  37.1k|            }
  155|  37.1k|         }
  156|  37.2k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 37.1k, False: 45]
  ------------------
  157|  37.1k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  37.1k|         }
  159|     45|         else {
  160|     45|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     45|         }
  162|  37.2k|         (void)m( result );
  163|  37.2k|         return result;
  164|  37.2k|      }
  165|  37.2k|   }
_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|  37.2k|      {
   73|  37.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|  37.2k|         else {
   84|  37.2k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  37.2k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  37.2k|      }
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|  37.2k|      {
   44|  37.2k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  37.2k|      }
_ZN3tao5pegtl5matchINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  74.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  74.4k|      else {
  108|  74.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  74.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  74.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|  74.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|  74.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|  74.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|  74.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|  74.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|  74.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  74.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  74.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  74.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|  74.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  74.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  74.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|  74.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  74.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  74.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  74.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  74.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 74.4k, 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|  74.4k|            else if constexpr( has_apply0_bool ) {
  153|  74.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  74.4k|            }
  155|  74.4k|         }
  156|  74.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 74.4k, False: 45]
  ------------------
  157|  74.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  74.4k|         }
  159|     45|         else {
  160|     45|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     45|         }
  162|  74.4k|         (void)m( result );
  163|  74.4k|         return result;
  164|  74.4k|      }
  165|  74.4k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii6xdigitELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  74.4k|      {
   73|  74.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|  74.4k|         else {
   84|  74.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  74.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  74.4k|      }
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|  74.4k|      {
   59|  74.4k|         return Rule::match( in );
   60|  74.4k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser15escaped_decbyteELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  59.8k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  59.8k|      else {
  108|  59.8k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  59.8k|         using iterator_t = typename ParseInput::iterator_t;
  111|  59.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|  59.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|  59.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|  59.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|  59.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|  59.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|  59.8k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  59.8k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  59.8k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  59.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|  59.8k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  59.8k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  59.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|  59.8k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  59.8k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  59.8k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  59.8k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  59.8k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 27.3k, False: 32.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|  27.3k|            else if constexpr( has_apply0_bool ) {
  153|  27.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  27.3k|            }
  155|  27.3k|         }
  156|  59.8k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 27.3k, False: 32.4k]
  ------------------
  157|  27.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  27.3k|         }
  159|  32.4k|         else {
  160|  32.4k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  32.4k|         }
  162|  59.8k|         (void)m( result );
  163|  59.8k|         return result;
  164|  59.8k|      }
  165|  59.8k|   }
_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|  59.8k|      {
   73|  59.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|  59.8k|         else {
   84|  59.8k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  59.8k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  59.8k|      }
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|  59.8k|      {
   44|  59.8k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  59.8k|      }
_ZN3tao5pegtl5matchINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS6_4RuleEEEEDaRT4_DpOT5_:
  103|  92.5k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  92.5k|      else {
  108|  92.5k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  92.5k|         using iterator_t = typename ParseInput::iterator_t;
  111|  92.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|  92.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|  92.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|  92.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|  92.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|  92.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|  92.5k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  92.5k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  92.5k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  92.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|  92.5k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  92.5k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  92.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|  92.5k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  92.5k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  92.5k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  92.5k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  92.5k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 35.3k, False: 57.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|  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|  92.5k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 35.3k, False: 57.2k]
  ------------------
  157|  35.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  35.3k|         }
  159|  57.2k|         else {
  160|  57.2k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  57.2k|         }
  162|  92.5k|         (void)m( result );
  163|  92.5k|         return result;
  164|  92.5k|      }
  165|  92.5k|   }
_ZN3tao5pegtl8internal20match_control_unwindINS0_5ascii5digitELNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
   72|  92.5k|      {
   73|  92.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|  92.5k|         else {
   84|  92.5k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  92.5k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  92.5k|      }
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|  92.5k|      {
   59|  92.5k|         return Rule::match( in );
   60|  92.5k|      }
_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|  27.3k|   {
  104|  27.3k|      if constexpr( !Control< Rule >::enable ) {
  105|  27.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|  27.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|  27.3k|      {
   44|  27.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.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|  27.3k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  27.3k|      else {
  108|  27.3k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  27.3k|         using iterator_t = typename ParseInput::iterator_t;
  111|  27.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|  27.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|  27.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|  27.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|  27.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|  27.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|  27.3k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  27.3k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  27.3k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  27.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|  27.3k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  27.3k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  27.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|  27.3k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  27.3k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  27.3k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  27.3k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  27.3k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 27.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|  27.3k|            else if constexpr( has_apply0_bool ) {
  153|  27.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  27.3k|            }
  155|  27.3k|         }
  156|  27.3k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 27.3k, False: 0]
  ------------------
  157|  27.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  27.3k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  27.3k|         (void)m( result );
  163|  27.3k|         return result;
  164|  27.3k|      }
  165|  27.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|  27.3k|      {
   73|  27.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|  27.3k|         else {
   84|  27.3k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  27.3k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  27.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|  27.3k|      {
   44|  27.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  27.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.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  32.4k|      else {
  108|  32.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  32.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  32.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|  32.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|  32.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|  32.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|  32.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|  32.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|  32.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  32.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  32.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  32.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|  32.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  32.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  32.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|  32.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  32.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  32.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  32.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  32.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 30.7k, False: 1.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|  30.7k|            else if constexpr( has_apply0_bool ) {
  153|  30.7k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  30.7k|            }
  155|  30.7k|         }
  156|  32.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 30.7k, False: 1.73k]
  ------------------
  157|  30.7k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  30.7k|         }
  159|  1.73k|         else {
  160|  1.73k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  1.73k|         }
  162|  32.4k|         (void)m( result );
  163|  32.4k|         return result;
  164|  32.4k|      }
  165|  32.4k|   }
_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.4k|      {
   73|  32.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|  32.4k|         else {
   84|  32.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  32.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  32.4k|      }
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.4k|      {
   59|  32.4k|         return Rule::match( in );
   60|  32.4k|      }
_ZN3tao5pegtl5matchINS0_5ascii3oneIJLc34EEEELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  1.73k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  1.73k|      else {
  108|  1.73k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  1.73k|         using iterator_t = typename ParseInput::iterator_t;
  111|  1.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|  1.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|  1.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|  1.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|  1.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|  1.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|  1.73k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  1.73k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  1.73k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  1.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|  1.73k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  1.73k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  1.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|  1.73k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  1.73k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  1.73k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  1.73k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  1.73k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 1.66k, False: 64]
  ------------------
  143|       |            if constexpr( has_apply_void ) {
  144|       |               Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( in ), st... );
  145|       |            }
  146|       |            else if constexpr( has_apply_bool ) {
  147|       |               result = Control< Rule >::template apply< Action >( m.iterator(), static_cast< const ParseInput& >( 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.66k|            else if constexpr( has_apply0_bool ) {
  153|  1.66k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  1.66k|            }
  155|  1.66k|         }
  156|  1.73k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 1.66k, False: 64]
  ------------------
  157|  1.66k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  1.66k|         }
  159|     64|         else {
  160|     64|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|     64|         }
  162|  1.73k|         (void)m( result );
  163|  1.73k|         return result;
  164|  1.73k|      }
  165|  1.73k|   }
_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.73k|      {
   73|  1.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|  1.73k|         else {
   84|  1.73k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  1.73k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  1.73k|      }
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.73k|      {
   59|  1.73k|         return Rule::match( in );
   60|  1.73k|      }
_ZN3tao5pegtl5matchIN8usbguard10RuleParser17character_regularELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEDaRT4_DpOT5_:
  103|  9.28M|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  9.28M|      else {
  108|  9.28M|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  9.28M|         using iterator_t = typename ParseInput::iterator_t;
  111|  9.28M|         constexpr bool has_apply_void = enable_action && internal::has_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.28M|         constexpr bool has_apply_bool = enable_action && internal::has_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.28M|         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.28M|         constexpr bool has_apply0_void = enable_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.28M|         constexpr bool has_apply0_bool = enable_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.28M|         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.28M|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  9.28M|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  9.28M|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  9.28M|         static_assert( !( has_apply0 && is_nothing ), "unexpected apply0() defined" );
  124|       |
  125|       |         if constexpr( !has_apply && std::is_base_of_v< require_apply, Action< Rule > > ) {
  126|       |            internal::missing_apply< Control< Rule >, Action >( in, st... );
  127|       |         }
  128|       |
  129|       |         if 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.28M|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  9.28M|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  9.28M|         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.28M|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  9.28M|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  9.28M|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  9.28M|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  9.28M|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 9.28M, 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|  9.28M|            else if constexpr( has_apply0_bool ) {
  153|  9.28M|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  9.28M|            }
  155|  9.28M|         }
  156|  9.28M|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 9.28M, False: 167]
  ------------------
  157|  9.28M|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  9.28M|         }
  159|    167|         else {
  160|    167|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|    167|         }
  162|  9.28M|         (void)m( result );
  163|  9.28M|         return result;
  164|  9.28M|      }
  165|  9.28M|   }
_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|  9.28M|      {
   73|  9.28M|#if defined( __cpp_exceptions )
   74|       |         if constexpr( has_unwind< Control< Rule >, void, const ParseInput&, States... > ) {
   75|       |            try {
   76|       |               return match_no_control< Rule, 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.28M|         else {
   84|  9.28M|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  9.28M|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  9.28M|      }
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|  9.28M|      {
   59|  9.28M|         return Rule::match( in );
   60|  9.28M|      }
_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|  32.3k|   {
  104|  32.3k|      if constexpr( !Control< Rule >::enable ) {
  105|  32.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|  32.3k|   }
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|  32.3k|      {
   44|  32.3k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  32.3k|      }
_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|  35.7k|   {
  104|  35.7k|      if constexpr( !Control< Rule >::enable ) {
  105|  35.7k|         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.7k|   }
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|  35.7k|      {
   44|  35.7k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  35.7k|      }
_ZN3tao5pegtl5matchINS0_3optIJN8usbguard10RuleParser7commentEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEDaRT4_DpOT5_:
  103|  42.4k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.4k|      else {
  108|  42.4k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.4k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.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|  42.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|  42.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|  42.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|  42.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|  42.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|  42.4k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.4k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.4k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.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|  42.4k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.4k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.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|  42.4k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.4k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.4k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.4k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.4k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 42.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|  42.4k|            else if constexpr( has_apply0_bool ) {
  153|  42.4k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  42.4k|            }
  155|  42.4k|         }
  156|  42.4k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 42.4k, False: 0]
  ------------------
  157|  42.4k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  42.4k|         }
  159|      0|         else {
  160|      0|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|      0|         }
  162|  42.4k|         (void)m( result );
  163|  42.4k|         return result;
  164|  42.4k|      }
  165|  42.4k|   }
_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|  42.4k|      {
   73|  42.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|  42.4k|         else {
   84|  42.4k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.4k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.4k|      }
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|  42.4k|      {
   44|  42.4k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.4k|      }
_ZN3tao5pegtl5matchINS0_4mustIJNS0_3eofEEEELNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS7_4RuleEEEEDaRT4_DpOT5_:
  103|  42.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.6k|      else {
  108|  42.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.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|  42.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|  42.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|  42.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|  42.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|  42.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|  42.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.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|  42.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.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|  42.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.3k, False: 4.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|  38.3k|            else if constexpr( has_apply0_bool ) {
  153|  38.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.3k|            }
  155|  38.3k|         }
  156|  42.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.3k, False: 4.27k]
  ------------------
  157|  38.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.3k|         }
  159|  4.27k|         else {
  160|  4.27k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.27k|         }
  162|  42.6k|         (void)m( result );
  163|  42.6k|         return result;
  164|  42.6k|      }
  165|  42.6k|   }
_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|  42.6k|      {
   73|  42.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|  42.6k|         else {
   84|  42.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.6k|      }
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|  42.6k|      {
   44|  42.6k|         return Rule::template match< A, M, Action, Control >( in, st... );
   45|  42.6k|      }
_ZN3tao5pegtl5matchINS0_3eofELNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyENS0_6normalENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS5_4RuleEEEEDaRT4_DpOT5_:
  103|  42.6k|   {
  104|       |      if constexpr( !Control< Rule >::enable ) {
  105|       |         return internal::match_no_control< Rule, A, M, Action, Control >( in, st... );
  106|       |      }
  107|  42.6k|      else {
  108|  42.6k|         constexpr bool enable_action = ( A == apply_mode::action );
  109|       |
  110|  42.6k|         using iterator_t = typename ParseInput::iterator_t;
  111|  42.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|  42.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|  42.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|  42.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|  42.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|  42.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|  42.6k|         static_assert( !( has_apply && has_apply0 ), "both apply() and apply0() defined" );
  120|       |
  121|  42.6k|         constexpr bool is_nothing = std::is_base_of_v< nothing< Rule >, Action< Rule > >;
  122|  42.6k|         static_assert( !( has_apply && is_nothing ), "unexpected apply() defined" );
  123|  42.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|  42.6k|         constexpr bool validate_nothing = std::is_base_of_v< maybe_nothing, Action< void > >;
  134|  42.6k|         constexpr bool is_maybe_nothing = std::is_base_of_v< maybe_nothing, Action< Rule > >;
  135|  42.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|  42.6k|         constexpr bool use_marker = has_apply || has_apply0_bool;
  ------------------
  |  Branch (137:38): [Folded, False: 0]
  |  Branch (137:51): [Folded, False: 0]
  ------------------
  138|       |
  139|  42.6k|         auto m = in.template mark< ( use_marker ? rewind_mode::required : rewind_mode::dontcare ) >();
  140|  42.6k|         Control< Rule >::start( static_cast< const ParseInput& >( in ), st... );
  141|  42.6k|         auto result = internal::match_control_unwind< Rule, A, ( use_marker ? rewind_mode::active : M ), Action, Control >( in, st... );
  142|  42.6k|         if( result ) {
  ------------------
  |  Branch (142:14): [True: 38.3k, False: 4.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|  38.3k|            else if constexpr( has_apply0_bool ) {
  153|  38.3k|               result = Control< Rule >::template apply0< Action >( static_cast< const ParseInput& >( in ), st... );
  154|  38.3k|            }
  155|  38.3k|         }
  156|  42.6k|         if( result ) {
  ------------------
  |  Branch (156:14): [True: 38.3k, False: 4.27k]
  ------------------
  157|  38.3k|            Control< Rule >::success( static_cast< const ParseInput& >( in ), st... );
  158|  38.3k|         }
  159|  4.27k|         else {
  160|  4.27k|            Control< Rule >::failure( static_cast< const ParseInput& >( in ), st... );
  161|  4.27k|         }
  162|  42.6k|         (void)m( result );
  163|  42.6k|         return result;
  164|  42.6k|      }
  165|  42.6k|   }
_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|  42.6k|      {
   73|  42.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|  42.6k|         else {
   84|  42.6k|            return match_no_control< Rule, A, M, Action, Control >( in, st... );
   85|  42.6k|         }
   86|       |#else
   87|       |         return match_no_control< Rule, A, M, Action, Control >( in, st... );
   88|       |#endif
   89|  42.6k|      }
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|  42.6k|      {
   59|  42.6k|         return Rule::match( in );
   60|  42.6k|      }

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

_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  46.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|  46.9k|         else {
   92|  46.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  46.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  46.9k|         }
   94|  46.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  46.9k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   178k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   178k|         else {
   92|   178k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   178k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   178k|         }
   94|   178k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   238k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   307k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   307k|         else {
   92|   307k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   307k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   307k|         }
   94|   307k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  6.31M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  3.85M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  2.45M|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   238k|      {}
_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|  46.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|  46.9k|         else {
   92|  46.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  46.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  46.9k|         }
   94|  46.9k|      }
_ZN3tao5pegtl6normalINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEvRKT_DpOT0_:
   36|  46.9k|      {}
_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|  46.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|  46.9k|         else {
   92|  46.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  46.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  46.9k|         }
   94|  46.9k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  46.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  89.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|  89.4k|         else {
   92|  89.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  89.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  89.4k|         }
   94|  89.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  89.4k|      {}
_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|  89.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|  89.4k|         else {
   92|  89.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  89.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  89.4k|         }
   94|  89.4k|      }
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  89.4k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  89.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|  89.4k|         else {
   92|  89.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  89.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  89.4k|         }
   94|  89.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  89.4k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  16.4k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc35EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  72.9k|      {}
_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|  16.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|  16.4k|         else {
   92|  16.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.4k|         }
   94|  16.4k|      }
_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|  16.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|  16.4k|         else {
   92|  16.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.4k|         }
   94|  16.4k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  16.4k|      {}
_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|  1.72M|      {
   88|       |         if constexpr( internal::has_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.72M|         else {
   92|  1.72M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.72M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.72M|         }
   94|  1.72M|      }
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.72M|      {}
_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|  1.72M|      {
   88|       |         if constexpr( internal::has_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.72M|         else {
   92|  1.72M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.72M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.72M|         }
   94|  1.72M|      }
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.72M|      {}
_ZN3tao5pegtl6normalINS0_3eofEE5matchILNS0_10apply_modeE0ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|  1.72M|      {
   88|       |         if constexpr( internal::has_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.72M|         else {
   92|  1.72M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.72M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.72M|         }
   94|  1.72M|      }
_ZN3tao5pegtl6normalINS0_3eofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.76M|      {}
_ZN3tao5pegtl6normalINS0_3eofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  54.8k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.71M|      {}
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.70M|      {}
_ZN3tao5pegtl6normalINS0_6not_atIJNS0_3eofEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  16.4k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3anyEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.70M|      {
   88|       |         if constexpr( internal::has_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.70M|         else {
   92|  1.70M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.70M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.70M|         }
   94|  1.70M|      }
_ZN3tao5pegtl6normalINS0_5ascii3anyEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.70M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3anyEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.70M|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.70M|      {}
_ZN3tao5pegtl6normalINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS6_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  16.4k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS0_5ascii3anyEEEEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  16.4k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  16.4k|      {}
_ZN3tao5pegtl6normalINS0_7if_mustINS0_5ascii3oneIJLc35EEEEJNS0_4starINS0_3seqIJNS0_6not_atIJNS0_3eofEEEENS3_3anyEEEEJEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  72.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE6apply0ITtTpTyENS3_19rule_parser_actionsENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE6apply0spfp0_EERKT0_DpOT1_:
   74|  16.4k|      {
   75|  16.4k|         return Action< Rule >::apply0( st... );
   76|  16.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  16.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser7commentEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  72.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  46.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|  46.9k|         else {
   92|  46.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  46.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  46.9k|         }
   94|  46.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  46.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  46.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|  46.9k|         else {
   92|  46.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  46.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  46.9k|         }
   94|  46.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  46.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  46.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|  46.9k|         else {
   92|  46.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  46.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  46.9k|         }
   94|  46.9k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  46.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  43.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_allowEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  3.47k|      {}
_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.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  3.47k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.60k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_blockEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    867|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|    867|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    867|         else {
   92|    867|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    867|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    867|         }
   94|    867|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|    867|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|     11|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_rejectEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    856|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|    856|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    856|         else {
   92|    856|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    856|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    856|         }
   94|    856|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|    856|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|    711|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_matchEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    145|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|    145|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    145|         else {
   92|    145|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    145|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    145|         }
   94|    145|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|    145|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|     39|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_deviceEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    106|      {}
_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|  46.8k|      {
   65|  46.8k|         const typename ParseInput::action_t action_input( begin, in );
   66|  46.8k|         return Action< Rule >::apply( action_input, st... );
   67|  46.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  46.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6targetEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    106|      {}
_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|  46.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|  46.8k|         else {
   92|  46.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  46.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  46.8k|         }
   94|  46.8k|      }
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS7_4RuleEEEEvRKT_DpOT0_:
   36|  46.8k|      {}
_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|  46.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|  46.8k|         else {
   92|  46.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  46.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  46.8k|         }
   94|  46.8k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   129k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   129k|         else {
   92|   129k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   129k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   129k|         }
   94|   129k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  2.21M|      {}
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   129k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   129k|         else {
   92|   129k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   129k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   129k|         }
   94|   129k|      }
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  2.16M|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  54.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  46.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|  46.7k|         else {
   92|  46.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  46.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  46.7k|         }
   94|  46.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  46.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  46.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|  46.7k|         else {
   92|  46.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  46.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  46.7k|         }
   94|  46.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   859k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  50.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|  50.4k|         else {
   92|  50.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  50.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  50.4k|         }
   94|  50.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  1.67M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  63.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|  63.7k|         else {
   92|  63.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  63.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  63.7k|         }
   94|  63.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  3.12M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.28M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.84M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  6.29k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.66M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  45.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|  45.9k|         else {
   92|  45.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.9k|         }
   94|  45.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.84M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.79M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  44.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   815k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  44.5k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.67k|         else {
   92|  3.67k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.67k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.67k|         }
   94|  3.67k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  1.17M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  1.17M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|    115|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.64k|         else {
   92|  3.64k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.64k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.64k|         }
   94|  3.64k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   815k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   815k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|     37|      {}
_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|  3.63k|      {
   65|  3.63k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.63k|         return Action< Rule >::apply( action_input, st... );
   67|  3.63k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.63k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9device_idEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  43.1k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEEN8usbguard10RuleParser9device_idEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS7_4RuleEEEEvRKT_DpOT0_:
   40|  46.7k|      {}
_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|  46.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|  46.7k|         else {
   92|  46.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  46.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  46.7k|         }
   94|  46.7k|      }
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS8_4RuleEEEEvRKT_DpOT0_:
   36|  46.7k|      {}
_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|  46.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|  46.7k|         else {
   92|  46.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  46.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  46.7k|         }
   94|  46.7k|      }
_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|  44.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|  44.5k|         else {
   92|  44.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  44.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  44.5k|         }
   94|  44.5k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  44.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  50.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|  50.3k|         else {
   92|  50.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  50.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  50.3k|         }
   94|  50.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  50.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  50.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|  50.3k|         else {
   92|  50.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  50.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  50.3k|         }
   94|  50.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  50.3k|      {}
_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|  50.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|  50.3k|         else {
   92|  50.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  50.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  50.3k|         }
   94|  50.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  50.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  50.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|  50.3k|         else {
   92|  50.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  50.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  50.3k|         }
   94|  50.3k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  50.3k|      {}
_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.59k|      {
   65|  3.59k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.59k|         return Action< Rule >::apply( action_input, st... );
   67|  3.59k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.58k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_idEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  46.7k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   816k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   816k|         else {
   92|   816k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   816k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   816k|         }
   94|   816k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   816k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   816k|         else {
   92|   816k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   816k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   816k|         }
   94|   816k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   825k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   825k|         else {
   92|   825k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   825k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   825k|         }
   94|   825k|      }
_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.57k|      {
   88|       |         if constexpr( internal::has_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.57k|         else {
   92|  3.57k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.57k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.57k|         }
   94|  3.57k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.57k|      {}
_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.57k|      {
   88|       |         if constexpr( internal::has_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.57k|         else {
   92|  3.57k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.57k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.57k|         }
   94|  3.57k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  3.57k|      {}
_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.57k|      {
   88|       |         if constexpr( internal::has_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.57k|         else {
   92|  3.57k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.57k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.57k|         }
   94|  3.57k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  43.6k|      {}
_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.57k|      {
   88|       |         if constexpr( internal::has_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.57k|         else {
   92|  3.57k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.57k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.57k|         }
   94|  3.57k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.57k|      {
   88|       |         if constexpr( internal::has_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.57k|         else {
   92|  3.57k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.57k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.57k|         }
   94|  3.57k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  43.6k|      {}
_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.57k|      {
   88|       |         if constexpr( internal::has_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.57k|         else {
   92|  3.57k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.57k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.57k|         }
   94|  3.57k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  43.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.81k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  40.8k|      {}
_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.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|  3.34k|         else {
   92|  3.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.34k|         }
   94|  3.34k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  40.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.47k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  36.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  36.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.89k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  33.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.63k|         else {
   92|  2.63k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.63k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.63k|         }
   94|  2.63k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  33.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.51k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  29.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.43k|         else {
   92|  2.43k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.43k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.43k|         }
   94|  2.43k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  29.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.93k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  27.0k|      {}
_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.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|  2.02k|         else {
   92|  2.02k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.02k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.02k|         }
   94|  2.02k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  27.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.96k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.0k|      {}
_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.74k|      {
   65|  1.74k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.74k|         return Action< Rule >::apply( action_input, st... );
   67|  1.74k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  19.5k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.0k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser17multiset_operatorENS0_4plusINS0_5ascii5blankEJEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  43.6k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.57k|      {
   88|       |         if constexpr( internal::has_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.57k|         else {
   92|  3.57k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.57k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.57k|         }
   94|  3.57k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  43.6k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  30.5k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  13.0k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.87k|         else {
   92|  4.87k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.87k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.87k|         }
   94|  4.87k|      }
_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.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_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  2.46k|      {}
_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.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_5ascii5blankEJEEEN8usbguard10RuleParser15device_id_valueEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS9_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSL_11char_traitsIcEENSL_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   810k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   810k|         else {
   92|   810k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   810k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   810k|         }
   94|   810k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  2.40k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15device_id_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     58|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_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|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  28.7k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  26.9k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.74k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.24k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15device_id_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.32k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   813k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   813k|         else {
   92|   813k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   813k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   813k|         }
   94|   813k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   813k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_vidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   813k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   813k|         else {
   92|   813k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   813k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   813k|         }
   94|   813k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex4EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.62M|         else {
   92|  1.62M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.62M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.62M|         }
   94|  1.62M|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.63M|      {
   88|       |         if constexpr( internal::has_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.63M|         else {
   92|  1.63M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.63M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.63M|         }
   94|  1.63M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.62M|         else {
   92|  1.62M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.62M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.62M|         }
   94|  1.62M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   811k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   811k|         else {
   92|   811k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   811k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   811k|         }
   94|   811k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10device_pidEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_10id_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   811k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   811k|         else {
   92|   811k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   811k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   811k|         }
   94|   811k|      }
_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|   811k|      {
   65|   811k|         const typename ParseInput::action_t action_input( begin, in );
   66|   811k|         return Action< Rule >::apply( action_input, st... );
   67|   811k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   811k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15device_id_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.49k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  3.12k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15device_id_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    437|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.12k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_idENS3_15device_id_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  47.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.12k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12id_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  47.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  47.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|  47.1k|         else {
   92|  47.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  47.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  47.1k|         }
   94|  47.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  47.1k|      {}
_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|  47.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|  47.1k|         else {
   92|  47.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  47.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  47.1k|         }
   94|  47.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  47.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  47.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|  47.1k|         else {
   92|  47.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  47.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  47.1k|         }
   94|  47.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  47.1k|      {}
_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|  4.06k|      {
   65|  4.06k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.06k|         return Action< Rule >::apply( action_input, st... );
   67|  4.06k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.06k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_nameEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  43.1k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   354k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   354k|         else {
   92|   354k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   354k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   354k|         }
   94|   354k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   354k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   354k|         else {
   92|   354k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   354k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   354k|         }
   94|   354k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   364k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   364k|         else {
   92|   364k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   364k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   364k|         }
   94|   364k|      }
_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|  4.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|  4.04k|         else {
   92|  4.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.04k|         }
   94|  4.04k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  27.9k|      {}
_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|  4.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|  4.04k|         else {
   92|  4.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.04k|         }
   94|  4.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  27.9k|      {}
_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|  4.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|  4.04k|         else {
   92|  4.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.04k|         }
   94|  4.04k|      }
_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|  4.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|  4.04k|         else {
   92|  4.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.04k|         }
   94|  4.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.04k|         else {
   92|  4.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.04k|         }
   94|  4.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.04k|         else {
   92|  4.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.04k|         }
   94|  4.04k|      }
_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.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|  3.65k|         else {
   92|  3.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.65k|         }
   94|  3.65k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.32k|         else {
   92|  3.32k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.32k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.32k|         }
   94|  3.32k|      }
_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.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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_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|      }
_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.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|  2.10k|         else {
   92|  2.10k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.10k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.10k|         }
   94|  2.10k|      }
_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|  2.14k|      {
   65|  2.14k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.14k|         return Action< Rule >::apply( action_input, st... );
   67|  2.14k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.04k|         else {
   92|  4.04k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.04k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.04k|         }
   94|  4.04k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.19k|         else {
   92|  6.19k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.19k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.19k|         }
   94|  6.19k|      }
_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|  3.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|  3.13k|         else {
   92|  3.13k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.13k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.13k|         }
   94|  3.13k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  19.4k|      {}
_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|  3.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|  3.08k|         else {
   92|  3.08k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.08k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.08k|         }
   94|  3.08k|      }
_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|   348k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   348k|         else {
   92|   348k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   348k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   348k|         }
   94|   348k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  18.9k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser12string_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    287|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.06k|      {
   88|       |         if constexpr( internal::has_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.06k|         else {
   92|  3.06k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.06k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.06k|         }
   94|  3.06k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  18.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  9.52k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   350k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   350k|         else {
   92|   350k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   350k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   350k|         }
   94|   350k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   416k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   350k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   350k|         else {
   92|   350k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   350k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   350k|         }
   94|   350k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  62.1M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   826k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  61.3M|      {}
_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|   349k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   349k|         else {
   92|   349k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   349k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   349k|         }
   94|   349k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|   349k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   349k|         else {
   92|   349k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   349k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   349k|         }
   94|   349k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   36|   410k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  13.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|  13.6M|         else {
   92|  13.6M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.6M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.6M|         }
   94|  13.6M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  13.2M|      {
   88|       |         if constexpr( internal::has_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.2M|         else {
   92|  13.2M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.2M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.2M|         }
   94|  13.2M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  61.3M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  13.2M|      {
   88|       |         if constexpr( internal::has_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.2M|         else {
   92|  13.2M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.2M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.2M|         }
   94|  13.2M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  61.3M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  13.2M|      {
   88|       |         if constexpr( internal::has_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.2M|         else {
   92|  13.2M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.2M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.2M|         }
   94|  13.2M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   112M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   773k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   111M|      {}
_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|   192k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   192k|         else {
   92|   192k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   192k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   192k|         }
   94|   192k|      }
_ZN3tao5pegtl6normalINS0_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|   192k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   192k|         else {
   92|   192k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   192k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   192k|         }
   94|   192k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   627k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   192k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   192k|         else {
   92|   192k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   192k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   192k|         }
   94|   192k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   773k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   192k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   192k|         else {
   92|   192k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   192k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   192k|         }
   94|   192k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   773k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   259k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   514k|      {}
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  83.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|  83.6k|         else {
   92|  83.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  83.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  83.6k|         }
   94|  83.6k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  83.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|  83.6k|         else {
   92|  83.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  83.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  83.6k|         }
   94|  83.6k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   259k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   167k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   167k|         else {
   92|   167k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   167k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   167k|         }
   94|   167k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   259k|      {}
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|    249|      {}
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   48|    249|      {
   49|    249|#if defined( __cpp_exceptions )
   50|    249|         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|    249|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   259k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   514k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   108k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   108k|         else {
   92|   108k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   108k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   108k|         }
   94|   108k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   514k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_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|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   745k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   251k|      {}
_ZN3tao5pegtl6normalINS0_5ascii5digitEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   493k|      {}
_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|  33.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|  33.5k|         else {
   92|  33.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.5k|         }
   94|  33.5k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  33.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|  33.5k|         else {
   92|  33.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.5k|         }
   94|  33.5k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   190k|      {}
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   190k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   190k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   323k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  75.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|  75.0k|         else {
   92|  75.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  75.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  75.0k|         }
   94|  75.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   323k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   315k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  8.27k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.79k|         else {
   92|  2.79k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.79k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.79k|         }
   94|  2.79k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   626k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    348|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   48|    348|      {
   49|    348|#if defined( __cpp_exceptions )
   50|    348|         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|    348|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   626k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  60.7M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12name_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  13.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|  13.0M|         else {
   92|  13.0M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.0M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.0M|         }
   94|  13.0M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   111M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   111M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.48k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  61.3M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.20k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   40|   408k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   44|  1.20k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   48|  1.20k|      {
   49|  1.20k|#if defined( __cpp_exceptions )
   50|  1.20k|         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.20k|      }
_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|   348k|      {
   65|   348k|         const typename ParseInput::action_t action_input( begin, in );
   66|   348k|         return Action< Rule >::apply( action_input, st... );
   67|   348k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   408k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  6.12k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  23.7k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|  2.10k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.39k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_nameENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  43.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.39k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14name_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  43.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  43.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|  43.4k|         else {
   92|  43.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.4k|         }
   94|  43.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  43.4k|      {}
_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|  43.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|  43.4k|         else {
   92|  43.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.4k|         }
   94|  43.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  43.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  43.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|  43.4k|         else {
   92|  43.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  43.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  43.4k|         }
   94|  43.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  43.4k|      {}
_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|  6.07k|      {
   65|  6.07k|         const typename ParseInput::action_t action_input( begin, in );
   66|  6.07k|         return Action< Rule >::apply( action_input, st... );
   67|  6.07k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  6.06k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8str_hashEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.3k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.9k|         else {
   92|  38.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.9k|         }
   94|  38.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.9k|         else {
   92|  38.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.9k|         }
   94|  38.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  49.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|  49.2k|         else {
   92|  49.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  49.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  49.2k|         }
   94|  49.2k|      }
_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|  6.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|  6.05k|         else {
   92|  6.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.05k|         }
   94|  6.05k|      }
_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|  6.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|  6.05k|         else {
   92|  6.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.05k|         }
   94|  6.05k|      }
_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|  6.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|  6.05k|         else {
   92|  6.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.05k|         }
   94|  6.05k|      }
_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|  6.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|  6.05k|         else {
   92|  6.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.05k|         }
   94|  6.05k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.05k|         else {
   92|  6.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.05k|         }
   94|  6.05k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.05k|         else {
   92|  6.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.05k|         }
   94|  6.05k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.69k|         else {
   92|  5.69k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.69k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.69k|         }
   94|  5.69k|      }
_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.36k|      {
   88|       |         if constexpr( internal::has_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.36k|         else {
   92|  3.36k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.36k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.36k|         }
   94|  3.36k|      }
_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.03k|      {
   88|       |         if constexpr( internal::has_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.03k|         else {
   92|  3.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.03k|         }
   94|  3.03k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_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|      }
_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.72k|      {
   88|       |         if constexpr( internal::has_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.72k|         else {
   92|  2.72k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.72k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.72k|         }
   94|  2.72k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5applyITtTpTyENS3_12hash_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|  3.61k|      {
   65|  3.61k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.61k|         return Action< Rule >::apply( action_input, st... );
   67|  3.61k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.05k|         else {
   92|  6.05k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.05k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.05k|         }
   94|  6.05k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  9.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|  9.09k|         else {
   92|  9.09k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.09k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.09k|         }
   94|  9.09k|      }
_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|  4.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|  4.58k|         else {
   92|  4.58k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.58k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.58k|         }
   94|  4.58k|      }
_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|  4.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|  4.52k|         else {
   92|  4.52k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.52k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.52k|         }
   94|  4.52k|      }
_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|  29.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|  29.2k|         else {
   92|  29.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  29.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  29.2k|         }
   94|  29.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  31.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|  31.6k|         else {
   92|  31.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.6k|         }
   94|  31.6k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  31.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|  31.6k|         else {
   92|  31.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.6k|         }
   94|  31.6k|      }
_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|  30.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|  30.5k|         else {
   92|  30.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.5k|         }
   94|  30.5k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  30.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|  30.5k|         else {
   92|  30.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.5k|         }
   94|  30.5k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  13.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|  13.4M|         else {
   92|  13.4M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.4M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.4M|         }
   94|  13.4M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  13.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|  13.4M|         else {
   92|  13.4M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.4M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.4M|         }
   94|  13.4M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  13.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|  13.4M|         else {
   92|  13.4M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.4M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.4M|         }
   94|  13.4M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  13.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|  13.4M|         else {
   92|  13.4M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.4M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.4M|         }
   94|  13.4M|      }
_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|  70.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|  70.6k|         else {
   92|  70.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  70.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  70.6k|         }
   94|  70.6k|      }
_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|  70.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|  70.6k|         else {
   92|  70.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  70.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  70.6k|         }
   94|  70.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  70.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|  70.6k|         else {
   92|  70.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  70.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  70.6k|         }
   94|  70.6k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  70.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|  70.6k|         else {
   92|  70.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  70.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  70.6k|         }
   94|  70.6k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  18.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|  18.2k|         else {
   92|  18.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  18.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  18.2k|         }
   94|  18.2k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  18.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|  18.2k|         else {
   92|  18.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  18.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  18.2k|         }
   94|  18.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  36.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|  36.4k|         else {
   92|  36.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  36.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  36.4k|         }
   94|  36.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  52.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|  52.4k|         else {
   92|  52.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  52.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  52.4k|         }
   94|  52.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  83.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|  83.2k|         else {
   92|  83.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  83.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  83.2k|         }
   94|  83.2k|      }
_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|  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_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  25.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|  25.3k|         else {
   92|  25.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  25.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  25.3k|         }
   94|  25.3k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    417|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    417|         else {
   92|    417|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    417|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    417|         }
   94|    417|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_12hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  13.3M|      {
   88|       |         if constexpr( internal::has_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.3M|         else {
   92|  13.3M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  13.3M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  13.3M|         }
   94|  13.3M|      }
_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|  30.2k|      {
   65|  30.2k|         const typename ParseInput::action_t action_input( begin, in );
   66|  30.2k|         return Action< Rule >::apply( action_input, st... );
   67|  30.2k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  5.37k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_8str_hashENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  5.37k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hash_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  37.7k|      {}
_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|  37.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|  37.7k|         else {
   92|  37.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.7k|         }
   94|  37.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.7k|      {}
_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|  37.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|  37.7k|         else {
   92|  37.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.7k|         }
   94|  37.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.7k|      {}
_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|  37.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|  37.7k|         else {
   92|  37.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.7k|         }
   94|  37.7k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  37.7k|      {}
_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|  2.99k|      {
   65|  2.99k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.99k|         return Action< Rule >::apply( action_input, st... );
   67|  2.99k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.99k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15str_parent_hashEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  34.7k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.47k|         else {
   92|  8.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.47k|         }
   94|  8.47k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.47k|         else {
   92|  8.47k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.47k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.47k|         }
   94|  8.47k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  14.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|  14.4k|         else {
   92|  14.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  14.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  14.4k|         }
   94|  14.4k|      }
_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|  2.97k|      {
   88|       |         if constexpr( internal::has_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.97k|         else {
   92|  2.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.97k|         }
   94|  2.97k|      }
_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|  2.97k|      {
   88|       |         if constexpr( internal::has_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.97k|         else {
   92|  2.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.97k|         }
   94|  2.97k|      }
_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|  2.97k|      {
   88|       |         if constexpr( internal::has_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.97k|         else {
   92|  2.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.97k|         }
   94|  2.97k|      }
_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|  2.97k|      {
   88|       |         if constexpr( internal::has_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.97k|         else {
   92|  2.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.97k|         }
   94|  2.97k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.97k|      {
   88|       |         if constexpr( internal::has_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.97k|         else {
   92|  2.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.97k|         }
   94|  2.97k|      }
_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|  2.97k|      {
   88|       |         if constexpr( internal::has_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.97k|         else {
   92|  2.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.97k|         }
   94|  2.97k|      }
_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|  2.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|  2.76k|         else {
   92|  2.76k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.76k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.76k|         }
   94|  2.76k|      }
_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|  2.54k|      {
   88|       |         if constexpr( internal::has_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.54k|         else {
   92|  2.54k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.54k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.54k|         }
   94|  2.54k|      }
_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.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|      }
_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.03k|      {
   88|       |         if constexpr( internal::has_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.03k|         else {
   92|  2.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.03k|         }
   94|  2.03k|      }
_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|  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_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.26k|      {
   65|  1.26k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.26k|         return Action< Rule >::apply( action_input, st... );
   67|  1.26k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.97k|      {
   88|       |         if constexpr( internal::has_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.97k|         else {
   92|  2.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.97k|         }
   94|  2.97k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.90k|         else {
   92|  3.90k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.90k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.90k|         }
   94|  3.90k|      }
_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|  1.99k|      {
   88|       |         if constexpr( internal::has_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.99k|         else {
   92|  1.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.99k|         }
   94|  1.99k|      }
_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|  1.93k|      {
   88|       |         if constexpr( internal::has_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.93k|         else {
   92|  1.93k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.93k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.93k|         }
   94|  1.93k|      }
_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|  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_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.91k|         else {
   92|  1.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.91k|         }
   94|  1.91k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.80k|         else {
   92|  5.80k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.80k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.80k|         }
   94|  5.80k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.80k|         else {
   92|  5.80k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.80k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.80k|         }
   94|  5.80k|      }
_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|  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_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_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_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.89M|      {
   88|       |         if constexpr( internal::has_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.89M|         else {
   92|  5.89M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.89M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.89M|         }
   94|  5.89M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.88M|      {
   88|       |         if constexpr( internal::has_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.88M|         else {
   92|  5.88M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.88M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.88M|         }
   94|  5.88M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.88M|      {
   88|       |         if constexpr( internal::has_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.88M|         else {
   92|  5.88M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.88M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.88M|         }
   94|  5.88M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.88M|      {
   88|       |         if constexpr( internal::has_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.88M|         else {
   92|  5.88M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.88M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.88M|         }
   94|  5.88M|      }
_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|   100k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   100k|         else {
   92|   100k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   100k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   100k|         }
   94|   100k|      }
_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|   100k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   100k|         else {
   92|   100k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   100k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   100k|         }
   94|   100k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   100k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   100k|         else {
   92|   100k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   100k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   100k|         }
   94|   100k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   100k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   100k|         else {
   92|   100k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   100k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   100k|         }
   94|   100k|      }
_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|  36.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|  36.0k|         else {
   92|  36.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  36.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  36.0k|         }
   94|  36.0k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  36.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|  36.0k|         else {
   92|  36.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  36.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  36.0k|         }
   94|  36.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  72.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|  72.0k|         else {
   92|  72.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  72.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  72.0k|         }
   94|  72.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  64.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|  64.4k|         else {
   92|  64.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  64.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  64.4k|         }
   94|  64.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  95.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|  95.6k|         else {
   92|  95.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  95.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  95.6k|         }
   94|  95.6k|      }
_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|  22.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|  22.0k|         else {
   92|  22.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.0k|         }
   94|  22.0k|      }
_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|  22.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|  22.0k|         else {
   92|  22.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.0k|         }
   94|  22.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  42.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|  42.3k|         else {
   92|  42.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.3k|         }
   94|  42.3k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    718|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    718|         else {
   92|    718|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    718|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    718|         }
   94|    718|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_19parent_hash_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.78M|         else {
   92|  5.78M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.78M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.78M|         }
   94|  5.78M|      }
_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|  4.84k|      {
   65|  4.84k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.84k|         return Action< Rule >::apply( action_input, st... );
   67|  4.84k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.39k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_15str_parent_hashENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  35.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.39k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21parent_hash_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  35.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  35.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|  35.0k|         else {
   92|  35.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.0k|         }
   94|  35.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  35.0k|      {}
_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|  35.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|  35.0k|         else {
   92|  35.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.0k|         }
   94|  35.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  35.0k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  35.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|  35.0k|         else {
   92|  35.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.0k|         }
   94|  35.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  35.0k|      {}
_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|  3.44k|      {
   65|  3.44k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.44k|         return Action< Rule >::apply( action_input, st... );
   67|  3.44k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.44k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_serialEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  31.5k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  8.99k|      {
   88|       |         if constexpr( internal::has_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.99k|         else {
   92|  8.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.99k|         }
   94|  8.99k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  8.99k|      {
   88|       |         if constexpr( internal::has_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.99k|         else {
   92|  8.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.99k|         }
   94|  8.99k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  15.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|  15.6k|         else {
   92|  15.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.6k|         }
   94|  15.6k|      }
_ZN3tao5pegtl6normalINS0_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|  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|      }
_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|  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|      }
_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|  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|      }
_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|  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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.17k|         else {
   92|  3.17k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.17k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.17k|         }
   94|  3.17k|      }
_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.97k|      {
   88|       |         if constexpr( internal::has_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.97k|         else {
   92|  2.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.97k|         }
   94|  2.97k|      }
_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.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|  2.78k|         else {
   92|  2.78k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.78k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.78k|         }
   94|  2.78k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.26k|      {
   88|       |         if constexpr( internal::has_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.26k|         else {
   92|  2.26k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.26k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.26k|         }
   94|  2.26k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_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.38k|      {
   65|  1.38k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.38k|         return Action< Rule >::apply( action_input, st... );
   67|  1.38k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.78k|         else {
   92|  3.78k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.78k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.78k|         }
   94|  3.78k|      }
_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.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|  1.91k|         else {
   92|  1.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.91k|         }
   94|  1.91k|      }
_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.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|  1.87k|         else {
   92|  1.87k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.87k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.87k|         }
   94|  1.87k|      }
_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|  4.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|  4.17k|         else {
   92|  4.17k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.17k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.17k|         }
   94|  4.17k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.86k|         else {
   92|  1.86k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.86k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.86k|         }
   94|  1.86k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.16k|         else {
   92|  6.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.16k|         }
   94|  6.16k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.16k|         else {
   92|  6.16k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.16k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.16k|         }
   94|  6.16k|      }
_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|  5.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|  5.59k|         else {
   92|  5.59k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.59k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.59k|         }
   94|  5.59k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.59k|         else {
   92|  5.59k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.59k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.59k|         }
   94|  5.59k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.88M|      {
   88|       |         if constexpr( internal::has_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.88M|         else {
   92|  2.88M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.88M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.88M|         }
   94|  2.88M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.87M|         else {
   92|  2.87M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.87M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.87M|         }
   94|  2.87M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.87M|         else {
   92|  2.87M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.87M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.87M|         }
   94|  2.87M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.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|  2.87M|         else {
   92|  2.87M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.87M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.87M|         }
   94|  2.87M|      }
_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|  22.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|  22.0k|         else {
   92|  22.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.0k|         }
   94|  22.0k|      }
_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|  22.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|  22.0k|         else {
   92|  22.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.0k|         }
   94|  22.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  22.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|  22.0k|         else {
   92|  22.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.0k|         }
   94|  22.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  22.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|  22.0k|         else {
   92|  22.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  22.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  22.0k|         }
   94|  22.0k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_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|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_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|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  11.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|  11.6k|         else {
   92|  11.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  11.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  11.6k|         }
   94|  11.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  16.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|  16.2k|         else {
   92|  16.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  16.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  16.2k|         }
   94|  16.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  25.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|  25.3k|         else {
   92|  25.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  25.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  25.3k|         }
   94|  25.3k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.13k|         else {
   92|  8.13k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.13k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.13k|         }
   94|  8.13k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.13k|         else {
   92|  8.13k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.13k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.13k|         }
   94|  8.13k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.07k|         else {
   92|  8.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.07k|         }
   94|  8.07k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    352|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    352|         else {
   92|    352|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    352|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    352|         }
   94|    352|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_14serial_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  2.85M|      {
   88|       |         if constexpr( internal::has_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.85M|         else {
   92|  2.85M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.85M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.85M|         }
   94|  2.85M|      }
_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|  5.39k|      {
   65|  5.39k|         const typename ParseInput::action_t action_input( begin, in );
   66|  5.39k|         return Action< Rule >::apply( action_input, st... );
   67|  5.39k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.96k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_10str_serialENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  31.8k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.96k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser16serial_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  31.8k|      {}
_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|  31.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|  31.8k|         else {
   92|  31.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.8k|         }
   94|  31.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  31.8k|      {}
_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|  31.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|  31.8k|         else {
   92|  31.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.8k|         }
   94|  31.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  31.8k|      {}
_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|  31.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|  31.8k|         else {
   92|  31.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.8k|         }
   94|  31.8k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  31.8k|      {}
_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.04k|      {
   65|  3.04k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.04k|         return Action< Rule >::apply( action_input, st... );
   67|  3.04k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.04k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12str_via_portEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  28.7k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  8.24k|      {
   88|       |         if constexpr( internal::has_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.24k|         else {
   92|  8.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.24k|         }
   94|  8.24k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  8.24k|      {
   88|       |         if constexpr( internal::has_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.24k|         else {
   92|  8.24k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.24k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.24k|         }
   94|  8.24k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  15.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|  15.2k|         else {
   92|  15.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.2k|         }
   94|  15.2k|      }
_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.03k|      {
   88|       |         if constexpr( internal::has_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.03k|         else {
   92|  3.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.03k|         }
   94|  3.03k|      }
_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.03k|      {
   88|       |         if constexpr( internal::has_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.03k|         else {
   92|  3.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.03k|         }
   94|  3.03k|      }
_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.03k|      {
   88|       |         if constexpr( internal::has_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.03k|         else {
   92|  3.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.03k|         }
   94|  3.03k|      }
_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.03k|      {
   88|       |         if constexpr( internal::has_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.03k|         else {
   92|  3.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.03k|         }
   94|  3.03k|      }
_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.03k|      {
   88|       |         if constexpr( internal::has_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.03k|         else {
   92|  3.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.03k|         }
   94|  3.03k|      }
_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.03k|      {
   88|       |         if constexpr( internal::has_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.03k|         else {
   92|  3.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.03k|         }
   94|  3.03k|      }
_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|  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|      }
_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|  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|      }
_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.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|      }
_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.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|      }
_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.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|  2.00k|         else {
   92|  2.00k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.00k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.00k|         }
   94|  2.00k|      }
_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.22k|      {
   65|  1.22k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.22k|         return Action< Rule >::apply( action_input, st... );
   67|  1.22k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.03k|      {
   88|       |         if constexpr( internal::has_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.03k|         else {
   92|  3.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.03k|         }
   94|  3.03k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.91k|         else {
   92|  3.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.91k|         }
   94|  3.91k|      }
_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|  1.99k|      {
   88|       |         if constexpr( internal::has_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.99k|         else {
   92|  1.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.99k|         }
   94|  1.99k|      }
_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|  1.93k|      {
   88|       |         if constexpr( internal::has_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.93k|         else {
   92|  1.93k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.93k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.93k|         }
   94|  1.93k|      }
_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|  3.97k|      {
   88|       |         if constexpr( internal::has_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.97k|         else {
   92|  3.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.97k|         }
   94|  3.97k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.91k|         else {
   92|  1.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.91k|         }
   94|  1.91k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.85k|         else {
   92|  5.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.85k|         }
   94|  5.85k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.85k|         else {
   92|  5.85k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.85k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.85k|         }
   94|  5.85k|      }
_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|  4.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|  4.87k|         else {
   92|  4.87k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.87k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.87k|         }
   94|  4.87k|      }
_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|  4.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|  4.87k|         else {
   92|  4.87k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.87k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.87k|         }
   94|  4.87k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.77M|      {
   88|       |         if constexpr( internal::has_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.77M|         else {
   92|  6.77M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.77M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.77M|         }
   94|  6.77M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.76M|      {
   88|       |         if constexpr( internal::has_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.76M|         else {
   92|  6.76M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76M|         }
   94|  6.76M|      }
_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.76M|      {
   88|       |         if constexpr( internal::has_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.76M|         else {
   92|  6.76M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76M|         }
   94|  6.76M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.76M|      {
   88|       |         if constexpr( internal::has_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.76M|         else {
   92|  6.76M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.76M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.76M|         }
   94|  6.76M|      }
_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|  45.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|  45.4k|         else {
   92|  45.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.4k|         }
   94|  45.4k|      }
_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|  45.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|  45.4k|         else {
   92|  45.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.4k|         }
   94|  45.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  45.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|  45.4k|         else {
   92|  45.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.4k|         }
   94|  45.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  45.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|  45.4k|         else {
   92|  45.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  45.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  45.4k|         }
   94|  45.4k|      }
_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|  19.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|  19.7k|         else {
   92|  19.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.7k|         }
   94|  19.7k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  19.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|  19.7k|         else {
   92|  19.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  19.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  19.7k|         }
   94|  19.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  25.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|  25.7k|         else {
   92|  25.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  25.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  25.7k|         }
   94|  25.7k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  38.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|  38.6k|         else {
   92|  38.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  38.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  38.6k|         }
   94|  38.6k|      }
_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|  10.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|  10.1k|         else {
   92|  10.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.1k|         }
   94|  10.1k|      }
_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|  10.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|  10.1k|         else {
   92|  10.1k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  10.1k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  10.1k|         }
   94|  10.1k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  15.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|  15.5k|         else {
   92|  15.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.5k|         }
   94|  15.5k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser16via_port_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    609|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    609|         else {
   92|    609|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    609|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    609|         }
   94|    609|      }
_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.72M|      {
   88|       |         if constexpr( internal::has_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.72M|         else {
   92|  6.72M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.72M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.72M|         }
   94|  6.72M|      }
_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|  4.62k|      {
   65|  4.62k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.62k|         return Action< Rule >::apply( action_input, st... );
   67|  4.62k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.39k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_12str_via_portENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  29.1k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  2.39k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18via_port_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  29.1k|      {}
_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|  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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  29.1k|      {}
_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|  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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  29.1k|      {}
_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|  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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  29.1k|      {}
_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|  4.85k|      {
   65|  4.85k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.85k|         return Action< Rule >::apply( action_input, st... );
   67|  4.85k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.85k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_with_interfaceEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.2k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|   187k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   187k|         else {
   92|   187k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   187k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   187k|         }
   94|   187k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   187k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   187k|         else {
   92|   187k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   187k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   187k|         }
   94|   187k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.78M|         else {
   92|  1.78M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.78M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.78M|         }
   94|  1.78M|      }
_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|  4.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|  4.84k|         else {
   92|  4.84k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.84k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.84k|         }
   94|  4.84k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  4.84k|      {}
_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|  4.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|  4.84k|         else {
   92|  4.84k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.84k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.84k|         }
   94|  4.84k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  4.84k|      {}
_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|  4.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|  4.84k|         else {
   92|  4.84k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.84k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.84k|         }
   94|  4.84k|      }
_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|  4.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|  4.84k|         else {
   92|  4.84k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.84k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.84k|         }
   94|  4.84k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.84k|         else {
   92|  4.84k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.84k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.84k|         }
   94|  4.84k|      }
_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|  4.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|  4.84k|         else {
   92|  4.84k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.84k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.84k|         }
   94|  4.84k|      }
_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|  4.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|  4.30k|         else {
   92|  4.30k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.30k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.30k|         }
   94|  4.30k|      }
_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|  4.03k|      {
   88|       |         if constexpr( internal::has_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.03k|         else {
   92|  4.03k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.03k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.03k|         }
   94|  4.03k|      }
_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|  3.72k|      {
   88|       |         if constexpr( internal::has_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.72k|         else {
   92|  3.72k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.72k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.72k|         }
   94|  3.72k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  3.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|  3.08k|         else {
   92|  3.08k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.08k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.08k|         }
   94|  3.08k|      }
_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|  2.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|  2.71k|         else {
   92|  2.71k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.71k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.71k|         }
   94|  2.71k|      }
_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|  3.23k|      {
   65|  3.23k|         const typename ParseInput::action_t action_input( begin, in );
   66|  3.23k|         return Action< Rule >::apply( action_input, st... );
   67|  3.23k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.84k|         else {
   92|  4.84k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.84k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.84k|         }
   94|  4.84k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  7.18k|      {
   88|       |         if constexpr( internal::has_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.18k|         else {
   92|  7.18k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.18k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.18k|         }
   94|  7.18k|      }
_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|  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|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  3.61k|      {}
_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|  3.56k|      {
   88|       |         if constexpr( internal::has_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.56k|         else {
   92|  3.56k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.56k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.56k|         }
   94|  3.56k|      }
_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|   179k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   179k|         else {
   92|   179k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   179k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   179k|         }
   94|   179k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  3.56k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15interface_valueENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     47|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  3.56k|      {
   88|       |         if constexpr( internal::has_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.56k|         else {
   92|  3.56k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.56k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.56k|         }
   94|  3.56k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.39k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_15interface_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.45k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   182k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   182k|         else {
   92|   182k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   182k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   182k|         }
   94|   182k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   182k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   182k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   182k|         else {
   92|   182k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   182k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   182k|         }
   94|   182k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   543k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   914k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   914k|         else {
   92|   914k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   914k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   914k|         }
   94|   914k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   370k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   173k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc58EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   361k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   361k|         else {
   92|   361k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   361k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   361k|         }
   94|   361k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   361k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   361k|         else {
   92|   361k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   361k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   361k|         }
   94|   361k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   361k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4hex2EE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   361k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   361k|         else {
   92|   361k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   361k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   361k|         }
   94|   361k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc42EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser22with_interface_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   171k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   171k|         else {
   92|   171k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   171k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   171k|         }
   94|   171k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   361k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14hex2orAsteriskEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|     46|      {}
_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|   180k|      {
   65|   180k|         const typename ParseInput::action_t action_input( begin, in );
   66|   180k|         return Action< Rule >::apply( action_input, st... );
   67|   180k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   180k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15interface_valueEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  2.06k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  4.44k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_15interface_valueEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    393|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.44k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_18str_with_interfaceENS3_15interface_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.44k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24with_interface_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  24.6k|      {}
_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|  24.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|  24.6k|         else {
   92|  24.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.6k|         }
   94|  24.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.6k|      {}
_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|  24.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|  24.6k|         else {
   92|  24.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.6k|         }
   94|  24.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.6k|      {}
_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|  24.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|  24.6k|         else {
   92|  24.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.6k|         }
   94|  24.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  24.6k|      {}
_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|  4.31k|      {
   65|  4.31k|         const typename ParseInput::action_t action_input( begin, in );
   66|  4.31k|         return Action< Rule >::apply( action_input, st... );
   67|  4.31k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.31k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser21str_with_connect_typeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  20.3k|      {}
_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|  14.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|  14.2k|         else {
   92|  14.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  14.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  14.2k|         }
   94|  14.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  14.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|  14.2k|         else {
   92|  14.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  14.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  14.2k|         }
   94|  14.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  24.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|  24.0k|         else {
   92|  24.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  24.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  24.0k|         }
   94|  24.0k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_12string_valueEEES6_EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.30k|         else {
   92|  4.30k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.30k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.30k|         }
   94|  4.30k|      }
_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|  4.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|  4.30k|         else {
   92|  4.30k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.30k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.30k|         }
   94|  4.30k|      }
_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|  4.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|  4.30k|         else {
   92|  4.30k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.30k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.30k|         }
   94|  4.30k|      }
_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|  4.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|  4.30k|         else {
   92|  4.30k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.30k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.30k|         }
   94|  4.30k|      }
_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|  4.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|  4.30k|         else {
   92|  4.30k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.30k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.30k|         }
   94|  4.30k|      }
_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|  4.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|  4.30k|         else {
   92|  4.30k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.30k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.30k|         }
   94|  4.30k|      }
_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|  4.11k|      {
   88|       |         if constexpr( internal::has_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.11k|         else {
   92|  4.11k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.11k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.11k|         }
   94|  4.11k|      }
_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|  3.99k|      {
   88|       |         if constexpr( internal::has_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.99k|         else {
   92|  3.99k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.99k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.99k|         }
   94|  3.99k|      }
_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|  3.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|  3.79k|         else {
   92|  3.79k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.79k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.79k|         }
   94|  3.79k|      }
_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|  3.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|  3.34k|         else {
   92|  3.34k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.34k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.34k|         }
   94|  3.34k|      }
_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|  3.11k|      {
   88|       |         if constexpr( internal::has_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.11k|         else {
   92|  3.11k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.11k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.11k|         }
   94|  3.11k|      }
_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.38k|      {
   65|  1.38k|         const typename ParseInput::action_t action_input( begin, in );
   66|  1.38k|         return Action< Rule >::apply( action_input, st... );
   67|  1.38k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.30k|         else {
   92|  4.30k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.30k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.30k|         }
   94|  4.30k|      }
_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|  6.93k|      {
   88|       |         if constexpr( internal::has_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.93k|         else {
   92|  6.93k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.93k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.93k|         }
   94|  6.93k|      }
_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|  3.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|  3.50k|         else {
   92|  3.50k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.50k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.50k|         }
   94|  3.50k|      }
_ZN3tao5pegtl6normalINS0_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|  3.44k|      {
   88|       |         if constexpr( internal::has_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.44k|         else {
   92|  3.44k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.44k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.44k|         }
   94|  3.44k|      }
_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|  8.54k|      {
   88|       |         if constexpr( internal::has_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.54k|         else {
   92|  8.54k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.54k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.54k|         }
   94|  8.54k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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|      }
_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|  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_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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_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|  9.26k|      {
   88|       |         if constexpr( internal::has_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.26k|         else {
   92|  9.26k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.26k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.26k|         }
   94|  9.26k|      }
_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|  9.26k|      {
   88|       |         if constexpr( internal::has_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.26k|         else {
   92|  9.26k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.26k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.26k|         }
   94|  9.26k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.70M|      {
   88|       |         if constexpr( internal::has_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.70M|         else {
   92|  9.70M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.70M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.70M|         }
   94|  9.70M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.70M|      {
   88|       |         if constexpr( internal::has_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.70M|         else {
   92|  9.70M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.70M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.70M|         }
   94|  9.70M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.70M|      {
   88|       |         if constexpr( internal::has_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.70M|         else {
   92|  9.70M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.70M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.70M|         }
   94|  9.70M|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS6_15escaped_decbyteENS6_14escaped_singleENS0_5ascii3oneIJLc34EEEEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS6_25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENSA_3eol7lf_crlfENSt3__112basic_stringIcNSO_11char_traitsIcEENSO_9allocatorIcEEEEEEJRNS5_4RuleEEEEbRT3_DpOT4_:
   87|  99.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|  99.3k|         else {
   92|  99.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  99.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  99.3k|         }
   94|  99.3k|      }
_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|  99.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|  99.3k|         else {
   92|  99.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  99.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  99.3k|         }
   94|  99.3k|      }
_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|  99.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|  99.3k|         else {
   92|  99.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  99.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  99.3k|         }
   94|  99.3k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  99.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|  99.3k|         else {
   92|  99.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  99.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  99.3k|         }
   94|  99.3k|      }
_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|  25.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|  25.8k|         else {
   92|  25.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  25.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  25.8k|         }
   94|  25.8k|      }
_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|  25.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|  25.8k|         else {
   92|  25.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  25.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  25.8k|         }
   94|  25.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  51.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|  51.7k|         else {
   92|  51.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  51.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  51.7k|         }
   94|  51.7k|      }
_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|  73.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|  73.4k|         else {
   92|  73.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  73.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  73.4k|         }
   94|  73.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser25with_connect_type_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   108k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   108k|         else {
   92|   108k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   108k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   108k|         }
   94|   108k|      }
_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|  30.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|  30.4k|         else {
   92|  30.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.4k|         }
   94|  30.4k|      }
_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|  30.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|  30.4k|         else {
   92|  30.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  30.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  30.4k|         }
   94|  30.4k|      }
_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|  42.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|  42.9k|         else {
   92|  42.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.9k|         }
   94|  42.9k|      }
_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.36k|      {
   88|       |         if constexpr( internal::has_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.36k|         else {
   92|  1.36k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.36k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.36k|         }
   94|  1.36k|      }
_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|  9.60M|      {
   88|       |         if constexpr( internal::has_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.60M|         else {
   92|  9.60M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.60M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.60M|         }
   94|  9.60M|      }
_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|  9.01k|      {
   65|  9.01k|         const typename ParseInput::action_t action_input( begin, in );
   66|  9.01k|         return Action< Rule >::apply( action_input, st... );
   67|  9.01k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.73k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_21str_with_connect_typeENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  20.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.73k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser27with_connect_type_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  20.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  20.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|  20.6k|         else {
   92|  20.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  20.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  20.6k|         }
   94|  20.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  20.6k|      {}
_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|  20.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|  20.6k|         else {
   92|  20.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  20.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  20.6k|         }
   94|  20.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  20.6k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  20.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|  20.6k|         else {
   92|  20.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  20.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  20.6k|         }
   94|  20.6k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  20.6k|      {}
_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|  7.35k|      {
   65|  7.35k|         const typename ParseInput::action_t action_input( begin, in );
   66|  7.35k|         return Action< Rule >::apply( action_input, st... );
   67|  7.35k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  7.34k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser6str_ifEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  13.2k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_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_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_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_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|  7.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|  7.32k|         else {
   92|  7.32k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.32k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.32k|         }
   94|  7.32k|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  7.32k|      {}
_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|  7.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|  7.32k|         else {
   92|  7.32k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.32k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.32k|         }
   94|  7.32k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  7.32k|      {}
_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|  7.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|  7.32k|         else {
   92|  7.32k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.32k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.32k|         }
   94|  7.32k|      }
_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|  7.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|  7.32k|         else {
   92|  7.32k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.32k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.32k|         }
   94|  7.32k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.32k|         else {
   92|  7.32k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.32k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.32k|         }
   94|  7.32k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_all_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.32k|         else {
   92|  7.32k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.32k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.32k|         }
   94|  7.32k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_one_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.12k|         else {
   92|  7.12k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.12k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.12k|         }
   94|  7.12k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser11str_none_ofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.91k|         else {
   92|  6.91k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.91k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.91k|         }
   94|  6.91k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18str_equals_orderedEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.69k|         else {
   92|  6.69k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.69k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.69k|         }
   94|  6.69k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.62k|         else {
   92|  5.62k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.62k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.62k|         }
   94|  5.62k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser13str_match_allEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.38k|         else {
   92|  5.38k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.38k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.38k|         }
   94|  5.38k|      }
_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|  2.15k|      {
   65|  2.15k|         const typename ParseInput::action_t action_input( begin, in );
   66|  2.15k|         return Action< Rule >::apply( action_input, st... );
   67|  2.15k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc123EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  7.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|  7.32k|         else {
   92|  7.32k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  7.32k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  7.32k|         }
   94|  7.32k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  8.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|  8.71k|         else {
   92|  8.71k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  8.71k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  8.71k|         }
   94|  8.71k|      }
_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|  4.97k|      {
   88|       |         if constexpr( internal::has_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.97k|         else {
   92|  4.97k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.97k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.97k|         }
   94|  4.97k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  4.97k|      {}
_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|  4.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|  4.84k|         else {
   92|  4.84k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.84k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.84k|         }
   94|  4.84k|      }
_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|   630k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   630k|         else {
   92|   630k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   630k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   630k|         }
   94|   630k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  3.73k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser9conditionENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     40|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.15k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser24attribute_value_multisetINS3_9conditionEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  2.97k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   635k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   635k|         else {
   92|   635k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   635k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   635k|         }
   94|   635k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   635k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   635k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   635k|         else {
   92|   635k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   635k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   635k|         }
   94|   635k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   635k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   635k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   635k|         else {
   92|   635k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   635k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   635k|         }
   94|   635k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   635k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|    347|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser8negationEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   634k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser8negationEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   635k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   635k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   635k|         else {
   92|   635k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   635k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   635k|         }
   94|   635k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   635k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   635k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   635k|         else {
   92|   635k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   635k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   635k|         }
   94|   635k|      }
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   635k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   634k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc45EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  1.15k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNSB_4RuleEEEEbRT3_DpOT4_:
   87|   634k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   634k|         else {
   92|   634k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   634k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   634k|         }
   94|   634k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   634k|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  25.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|  25.5M|         else {
   92|  25.5M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  25.5M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  25.5M|         }
   94|  25.5M|      }
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  25.5M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  24.9M|      {}
_ZN3tao5pegtl6normalINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   634k|      {}
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii6rangesIJLc97ELc122ELc65ELc90ELc48ELc57ELc45EEEEJEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|   634k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   634k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser20condition_identifierEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.15k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|   634k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   634k|         else {
   92|   634k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   634k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   634k|         }
   94|   634k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   634k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   634k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   634k|         else {
   92|   634k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   634k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   634k|         }
   94|   634k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|   634k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|   634k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   634k|         else {
   92|   634k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   634k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   634k|         }
   94|   634k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|   634k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  48.7k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc40EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|   585k|      {}
_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|  48.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|  48.7k|         else {
   92|  48.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.7k|         }
   94|  48.7k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  48.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|  48.7k|         else {
   92|  48.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  48.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  48.7k|         }
   94|  48.7k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   36|  48.7k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  50.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|  50.7M|         else {
   92|  50.7M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  50.7M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  50.7M|         }
   94|  50.7M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  50.7M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  48.5k|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSB_11char_traitsIcEENSB_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   44|  50.7M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  50.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|  50.7M|         else {
   92|  50.7M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  50.7M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  50.7M|         }
   94|  50.7M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  50.7M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  50.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|  50.7M|         else {
   92|  50.7M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  50.7M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  50.7M|         }
   94|  50.7M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  50.7M|      {}
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  50.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|  50.7M|         else {
   92|  50.7M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  50.7M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  50.7M|         }
   94|  50.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|   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|      }
_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|   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|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|   146k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_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|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_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|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  33.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|  33.2k|         else {
   92|  33.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.2k|         }
   94|  33.2k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  33.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|  33.2k|         else {
   92|  33.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  33.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  33.2k|         }
   94|  33.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  66.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|  66.5k|         else {
   92|  66.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  66.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  66.5k|         }
   94|  66.5k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|   113k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   113k|         else {
   92|   113k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   113k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   113k|         }
   94|   113k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|   155k|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|   155k|         else {
   92|   155k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|   155k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|   155k|         }
   94|   155k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_7rep_optILj2EJNS0_5ascii5digitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  31.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|  31.4k|         else {
   92|  31.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.4k|         }
   94|  31.4k|      }
_ZN3tao5pegtl6normalINS0_7rep_optILj2EJNS0_5ascii5digitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  31.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|  31.4k|         else {
   92|  31.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  31.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  31.4k|         }
   94|  31.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14escaped_singleEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  81.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|  81.9k|         else {
   92|  81.9k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  81.9k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  81.9k|         }
   94|  81.9k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc41EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|    288|      {
   88|       |         if constexpr( internal::has_match< bool, Rule, A, M, Action, Control, ParseInput, States... > ) {
   89|       |            return Action< Rule >::template match< Rule, A, M, Action, Control >( in, st... );
   90|       |         }
   91|    288|         else {
   92|    288|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|    288|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|    288|         }
   94|    288|      }
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   146k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|     75|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser15escaped_hexbyteENS4_15escaped_decbyteENS4_14escaped_singleENS0_5ascii3oneIJLc41EEEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS8_3eol7lf_crlfENSt3__112basic_stringIcNSI_11char_traitsIcEENSI_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   48|     75|      {
   49|     75|#if defined( __cpp_exceptions )
   50|     75|         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|     75|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   146k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc41EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  50.5M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_17condition_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  50.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|  50.5M|         else {
   92|  50.5M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  50.5M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  50.5M|         }
   94|  50.5M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  50.7M|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc41EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    277|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   40|  48.3k|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   44|    277|      {}
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc41EEEEJN8usbguard10RuleParser9characterILc41EEEEEEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS6_4RuleEEEEvRKT_DpOT0_:
   48|    277|      {
   49|    277|#if defined( __cpp_exceptions )
   50|    277|         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|    277|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  48.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser18condition_argumentEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|   585k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser18condition_argumentEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|   633k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE5applyITtTpTyENS3_17condition_actionsENS0_8internal8iteratorENS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEDTclsrT_IJS4_EE5applyclsr3stdE7declvalIRKNT1_8action_tEEEspfp1_EERKT0_RKSR_DpOT2_:
   64|   633k|      {
   65|   633k|         const typename ParseInput::action_t action_input( begin, in );
   66|   633k|         return Action< Rule >::apply( action_input, st... );
   67|   633k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|   631k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9conditionEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  1.15k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  4.45k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser24attribute_value_multisetINS4_9conditionEEES6_EEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    683|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.45k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_6str_ifENS3_9conditionEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  13.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.45k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser19condition_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  13.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  13.9k|      {}
_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|  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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  13.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_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|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   36|  13.9k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  4.09k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9str_labelEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  9.90k|      {}
_ZN3tao5pegtl6normalINS0_4plusINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  9.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|  9.86k|         else {
   92|  9.86k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.86k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.86k|         }
   94|  9.86k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  9.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|  9.86k|         else {
   92|  9.86k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.86k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.86k|         }
   94|  9.86k|      }
_ZN3tao5pegtl6normalINS0_5ascii5blankEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  15.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|  15.8k|         else {
   92|  15.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  15.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  15.8k|         }
   94|  15.8k|      }
_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.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|  4.07k|         else {
   92|  4.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.07k|         }
   94|  4.07k|      }
_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.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|  4.07k|         else {
   92|  4.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.07k|         }
   94|  4.07k|      }
_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.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|  4.07k|         else {
   92|  4.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.07k|         }
   94|  4.07k|      }
_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.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|  4.07k|         else {
   92|  4.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.07k|         }
   94|  4.07k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17multiset_operatorEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.07k|         else {
   92|  4.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.07k|         }
   94|  4.07k|      }
_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.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|  4.07k|         else {
   92|  4.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.07k|         }
   94|  4.07k|      }
_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.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|      }
_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.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|  3.46k|         else {
   92|  3.46k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.46k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.46k|         }
   94|  3.46k|      }
_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.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|  3.39k|         else {
   92|  3.39k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  3.39k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  3.39k|         }
   94|  3.39k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser10str_equalsEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_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|      }
_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.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|  2.90k|         else {
   92|  2.90k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.90k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.90k|         }
   94|  2.90k|      }
_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.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_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.07k|         else {
   92|  4.07k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.07k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.07k|         }
   94|  4.07k|      }
_ZN3tao5pegtl6normalINS0_4starINS0_5ascii5blankEJEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  4.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|  4.65k|         else {
   92|  4.65k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  4.65k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  4.65k|         }
   94|  4.65k|      }
_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.36k|      {
   88|       |         if constexpr( internal::has_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.36k|         else {
   92|  2.36k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.36k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.36k|         }
   94|  2.36k|      }
_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.29k|      {
   88|       |         if constexpr( internal::has_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.29k|         else {
   92|  2.29k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.29k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.29k|         }
   94|  2.29k|      }
_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.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_5ascii3oneIJLc125EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  2.29k|      {
   88|       |         if constexpr( internal::has_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.29k|         else {
   92|  2.29k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  2.29k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  2.29k|         }
   94|  2.29k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12string_valueEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.77k|         else {
   92|  6.77k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.77k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.77k|         }
   94|  6.77k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  6.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|  6.77k|         else {
   92|  6.77k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  6.77k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  6.77k|         }
   94|  6.77k|      }
_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|  5.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|  5.89k|         else {
   92|  5.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.89k|         }
   94|  5.89k|      }
_ZN3tao5pegtl6normalINS0_5untilINS0_5ascii3oneIJLc34EEEEJN8usbguard10RuleParser9characterILc34EEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS7_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNS6_4RuleEEEEbRT3_DpOT4_:
   87|  5.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|  5.89k|         else {
   92|  5.89k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  5.89k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  5.89k|         }
   94|  5.89k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.38M|      {
   88|       |         if constexpr( internal::has_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.38M|         else {
   92|  9.38M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.38M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.38M|         }
   94|  9.38M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser9characterILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.38M|      {
   88|       |         if constexpr( internal::has_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.38M|         else {
   92|  9.38M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.38M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.38M|         }
   94|  9.38M|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_escapedILc34EEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.38M|      {
   88|       |         if constexpr( internal::has_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.38M|         else {
   92|  9.38M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.38M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.38M|         }
   94|  9.38M|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc92EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  9.38M|      {
   88|       |         if constexpr( internal::has_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.38M|         else {
   92|  9.38M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.38M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.38M|         }
   94|  9.38M|      }
_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|  97.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|  97.0k|         else {
   92|  97.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  97.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  97.0k|         }
   94|  97.0k|      }
_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|  97.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|  97.0k|         else {
   92|  97.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  97.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  97.0k|         }
   94|  97.0k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_hexbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  97.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|  97.0k|         else {
   92|  97.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  97.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  97.0k|         }
   94|  97.0k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc120EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  97.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|  97.0k|         else {
   92|  97.0k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  97.0k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  97.0k|         }
   94|  97.0k|      }
_ZN3tao5pegtl6normalINS0_8internal4mustIJNS0_3repILj2EJNS0_5ascii6xdigitEEEEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS5_3eol7lf_crlfENSt3__112basic_stringIcNSK_11char_traitsIcEENSK_9allocatorIcEEEEEEJRNSD_4RuleEEEEbRT3_DpOT4_:
   87|  37.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|  37.2k|         else {
   92|  37.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.2k|         }
   94|  37.2k|      }
_ZN3tao5pegtl6normalINS0_3repILj2EJNS0_5ascii6xdigitEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS3_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNSA_4RuleEEEEbRT3_DpOT4_:
   87|  37.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|  37.2k|         else {
   92|  37.2k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  37.2k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  37.2k|         }
   94|  37.2k|      }
_ZN3tao5pegtl6normalINS0_5ascii6xdigitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  74.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|  74.4k|         else {
   92|  74.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  74.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  74.4k|         }
   94|  74.4k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15escaped_decbyteEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  59.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|  59.8k|         else {
   92|  59.8k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  59.8k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  59.8k|         }
   94|  59.8k|      }
_ZN3tao5pegtl6normalINS0_5ascii5digitEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE1ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS8_4RuleEEEEbRT3_DpOT4_:
   87|  92.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|  92.5k|         else {
   92|  92.5k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  92.5k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  92.5k|         }
   94|  92.5k|      }
_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|  27.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|  27.3k|         else {
   92|  27.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.3k|         }
   94|  27.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|  27.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|  27.3k|         else {
   92|  27.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  27.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  27.3k|         }
   94|  27.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.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|  32.4k|         else {
   92|  32.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  32.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  32.4k|         }
   94|  32.4k|      }
_ZN3tao5pegtl6normalINS0_5ascii3oneIJLc34EEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS2_3eol7lf_crlfENSt3__112basic_stringIcNSG_11char_traitsIcEENSG_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  1.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|  1.73k|         else {
   92|  1.73k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  1.73k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  1.73k|         }
   94|  1.73k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser17character_regularEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyENS3_13label_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEbRT3_DpOT4_:
   87|  9.28M|      {
   88|       |         if constexpr( internal::has_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.28M|         else {
   92|  9.28M|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  9.28M|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  9.28M|         }
   94|  9.28M|      }
_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.61k|      {
   65|  5.61k|         const typename ParseInput::action_t action_input( begin, in );
   66|  5.61k|         return Action< Rule >::apply( action_input, st... );
   67|  5.61k|      }
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.43k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser14rule_attributeINS3_9str_labelENS3_12string_valueEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  10.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  3.43k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15label_attributeEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  10.2k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  35.7k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser15rule_attributesEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|  10.2k|      {}
_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|  32.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|  32.3k|         else {
   92|  32.3k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  32.3k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  32.3k|         }
   94|  32.3k|      }
_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|  35.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|  35.7k|         else {
   92|  35.7k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  35.7k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  35.7k|         }
   94|  35.7k|      }
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  32.0k|      {}
_ZN3tao5pegtl6normalINS0_4listIN8usbguard10RuleParser15rule_attributesENS0_4plusINS0_5ascii5blankEJEEEvEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS7_3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|  8.11k|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_4plusINS0_5ascii5blankEJEEENS0_4listIN8usbguard10RuleParser15rule_attributesES6_vEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS4_3eol7lf_crlfENSt3__112basic_stringIcNSJ_11char_traitsIcEENSJ_9allocatorIcEEEEEEJRNS8_4RuleEEEEvRKT_DpOT0_:
   40|  42.4k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyENS4_19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS3_4RuleEEEEbRT3_DpOT4_:
   87|  42.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|  42.4k|         else {
   92|  42.4k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.4k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.4k|         }
   94|  42.4k|      }
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   36|  42.4k|      {}
_ZN3tao5pegtl6normalINS0_3optIJN8usbguard10RuleParser7commentEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSE_11char_traitsIcEENSE_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  42.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  42.4k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser4ruleEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   44|    106|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   40|  42.4k|      {}
_ZN3tao5pegtl6normalINS0_3sorIJN8usbguard10RuleParser7commentENS4_4ruleEEEEE7failureINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS3_4RuleEEEEvRKT_DpOT0_:
   44|    106|      {}
_ZN3tao5pegtl6normalINS0_3optIJNS0_3sorIJN8usbguard10RuleParser7commentENS5_4ruleEEEEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS4_4RuleEEEEvRKT_DpOT0_:
   40|  42.6k|      {}
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE0ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSH_11char_traitsIcEENSH_9allocatorIcEEEEEEJRNS9_4RuleEEEEbRT3_DpOT4_:
   87|  42.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|  42.6k|         else {
   92|  42.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.6k|         }
   94|  42.6k|      }
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE5startINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   36|  42.6k|      {}
_ZN3tao5pegtl6normalINS0_3eofEE5matchILNS0_10apply_modeE1ELNS0_11rewind_modeE2ETtTpTyEN8usbguard10RuleParser19rule_parser_actionsETtTpTyES1_NS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSF_11char_traitsIcEENSF_9allocatorIcEEEEEEJRNS7_4RuleEEEEbRT3_DpOT4_:
   87|  42.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|  42.6k|         else {
   92|  42.6k|            return TAO_PEGTL_NAMESPACE::match< Rule, A, M, Action, Control >( in, st... );
  ------------------
  |  |    8|  42.6k|#define TAO_PEGTL_NAMESPACE tao::pegtl
  ------------------
   93|  42.6k|         }
   94|  42.6k|      }
_ZN3tao5pegtl6normalINS0_3eofEE5raiseINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   48|  4.27k|      {
   49|  4.27k|#if defined( __cpp_exceptions )
   50|  4.27k|         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.27k|      }
_ZN3tao5pegtl6normalINS0_4mustIJNS0_3eofEEEEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRN8usbguard4RuleEEEEvRKT_DpOT0_:
   40|  38.3k|      {}
_ZN3tao5pegtl6normalIN8usbguard10RuleParser12rule_grammarEE7successINS0_12string_inputILNS0_13tracking_modeE0ENS0_5ascii3eol7lf_crlfENSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJRNS2_4RuleEEEEvRKT_DpOT0_:
   40|  38.3k|      {}

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

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

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

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